Internal, hidden from programmers, and we don't need them!

References: References cannot be made to raw data-types, but who needs that; only to objects(from classes).

Passing By Reference: Any data-type can be passed to a function by-reference using the keyword ByRef in the function's declaration. No other code need be written in the called function or calling function; the reference is treated like any other variable.

Linked Lists: This is the only other sane use for pointers. Visual Basic provides dynamic arrays (variable length arrays) and "collections" for any purpose where a C programmer would use a linked-list. Besides, you could still make a linked-list using true references.

Function Pointers? See Low Level Operations.

And they're crap!

References: Declare a pointer of the same type, and copy the address of another variable to it. (Rubbish!) Then, dereference it using the same notation used to declare the pointer (which is also the same operator as multiplication) (OMG!)

Passing By Reference: Same notation as local pointers.

Linked Lists: These are the only other use for pointers I can think of, yet you could still make a linked-list in Basic using true references, but why would you? (See other side)

Function Pointers? Yup.

One statement per line, no terminating character, unless:

- You want to put multiple statements on one line. Use the colon (:) to separate these statements.

- You want to spread one statement over multiple lines. Use the underscore (_).

Always use a semi-colon to separate statements, no matter what. (Rubbish!)

Zero, by default, or change the default to 1, or personally specify explicitly.

Always zero.

True = -1 or non-zero, False = 0

Visual Basic does not have separate 'gate' operator for booleans and bitwise-ops. 'And', 'Or', 'Xor' and 'Not' all apply the bitwise operation on integers, and the boolean operation on booleans. Simple.

True = non-zero, False = 0

Logic-gate operations are separate between booleans and bitwise-ops. Boolean: && (and), || (or), ! (not). Bitwise: & (and), | (or), ^ (xor), ! (not). Or the designers could have just made booleans separate to regular integers. And what's wrong with using words, as long as they're small?

Basic offers the built-in data-type, "String", where the memory used is #BytesInString+2. ie. it dynamically allocates memory based on the size of the string. Data within the strings is treated as though the data belongs in the variable, ie. there are no pointers/references about it (they're internal).

You can still use character-arrays if you want (but that would be pointless), or have fixed-length strings.

Create a fixed length char-array, in which you must leave room for a terminating character (chr(0), '/0'). Or you can include the string.h file and use strings as in Basic.

Structures: Except they're called User-Defined-Types and you don't have to declare the structure and type separatly.

Classes: VB's all about OOP.

Polymorphism:

Structures: Except you also have to define a type that points to that struct. (Huh?)

Classes:

Polymorphism:

Always Interpreted when run through the editor, but when creating the .exe file, you have the choice of compiling to p-code (interpreted) or to native code.

Fully compiles to native code, even when you're not finished.

Syntax: Checks the syntax of each line when you 'lose focus' of that line, marks it red (default) if there is a syntax error and MsgBoxes you about it (optional).

Semantic: Built-in use of break-points, step, step-out, step-over, run-to-cursor, etc.

Run-Time Editing: You can pause the program, make changes to the code, then continue without recompiling. Why? It's an interpreted language. Restrictions apply of course, like you can't add a new function - that certainly needs to be recompiled.

Immediate Window: You can pause the program, then type any statement in the immediate window to run that statement without it being in the program. Great for testing new functions and viewing variable details.

Watch Window: Yup.

Syntax: You don't know you have a problem until you try to compile it, then tells you there are 38 errors, 90% of which, the accused error is on a different line to where the error actually is.

Semantic: Depends on your editor. Some good editors have the same features as Basic, but aren't always implemented very well. Some require you to compile first, then use a separate program to debug.

Run-Time Editing: You must be joking.

Immediate Window: Nope. To print your variables, you have to actually modify your program to print them every iteration! (And you should already know how painstaking it is to have to recompile.) To test your functions, you must type up a main() function, then later, after putting in a real main() function, you decide to change one of your first functions, and have to go stuff up your main() function again to fix it.

Watch Window: Depends.