Comparison of C/C++ and FreeBASIC

C/C++ | FreeBASIC

variable declaration

`int a; int a, b, c;` | `dim a as long dim as long a, b, c`

uninitialized variable

`int a;` | `dim a as long = any`

zero-initialized variable

`int a = 0;` | `dim a as long`

initialized variable

`int a = 123;` | `dim a as long = 123`

array

`int a[4]; a[0] = 1;` | `dim a(0 to 3) as long a(0) = 1`

pointer

`int a; int *p; p = &a; *p = 123;` | `dim a as long dim p as long ptr p = @a *p = 123`

structure, user-defined type

`struct UDT { int myfield; }` | `type UDT myfield as long end type`

typedef, type alias

`typedef int myint;` | `type myint as long`

struct pointer

`struct UDT x; struct UDT *p; p = &x; p->myfield = 123;` | `dim x as UDT dim p as UDT ptr p = @x p->myfield = 123`

function declaration

`int foo( void );` | `declare function foo( ) as long`

function body

`int foo( void ) { return 123; }` | `function foo( ) as long return 123 end function`

sub declaration

`void foo( void );` | `declare sub foo( )`

sub body

`void foo( void ) { }` | `sub foo( ) end sub`

byval parameters

`void foo( int param ); foo( a );` | `declare sub foo( byval param as long ) foo( a )`

byval pointers to parameters

`void foo( int *param ); foo( &a );` | `declare sub foo( byval param as long ptr ) foo( @a )`

byref parameters

`void foo( int& param ); foo( a );` | `declare sub foo( byref param as long ) foo( a )`

statement separator

`;` | `:` `<end-of-line>`

for loop

`for (int i = 0; i < 10; i++) { ... }` | `for i as long = 0 to 9 ... next`

while loop

`while (condition) { ... }` | `while condition ... wend`

do-while loop

`do { ... } while (condition);` | `do ... loop while condition`

if block

`if (condition) { ... } else if (condition) { ... } else { ... }` | `if condition then ... elseif condition then ... else ... end if`

switch, select

`switch (a) { case 1: ... break; case 2: case 3: ... break; default: ... break; }` | `select case a case 1 ... case 2, 3 ... case else ... end select`

string literals, zstrings

`char *s = "Hello!"; char s[] = "Hello!";` | `dim s as zstring ptr = @"Hello!" dim s as zstring * 6+1 = "Hello!"`

hello world

`#include <stdio.h> int main() { printf("Hello!\n"); return 0; }` | `print "Hello!"`

comments

`// foo /* foo */` | `' foo /' foo '/`

compile-time checks

`#if a` `#elif b` `#else` `#endif` | `#if a` `#elseif b` `#else` `#endif`

compile-time target system checks

`#ifdef _WIN32` | `#ifdef __FB_WIN32__`

module/header file names

`foo.c, foo.h` | `foo.bas, foo.bi`

typical compiler command to create an executable

`gcc foo.c -o foo` | `fbc foo.bas`

Last reviewed by MrSwiss on April 6, 2018 Note: changed Integer to Long (where needed)