Quote:Original post by midasmax
Correct me if I'm wrong, but I believe that:

*** Source Snippet Removed ***

and

*** Source Snippet Removed ***

are actually doing the same thing. Because the variable "var" is actually pointing to the address of the object ( of SomeClass ) in the heap. It's just that in C++, you need to specifically state that your variable is a pointer-to-address. In C#, you appear to be assigning a variable to an object, but what is actually happening is that you're assigning the variable to the *address* of that object.

Java programmers would also be familiar with this.

not exactly... the first one must be deleted "manually", the second one is automatically deleted when it gets out of scope (it gets placed on the stack, and is removed when teh stack unwinds/etc). In java, and in a way, C#... the "manually" is handled automatically by a garbage collector... and it is impossible to create the other one, since they are in essence, stackless by design.

I found that learning about the STL collections helped my understanding. Like using a Linked List, or stack.

Try reading this maybe it helps you understand? :)

http://www.codersource.net/c++_pointers.html

All code examples will be in C++, not in C# as I have yet to learn it.

Java variables are all either primitive values or references to objects (including arrays).

C/C++, however, allows you to have the values themselves, pointers to the values themselves, pointers to pointers to the values themselves, etc. for primitives, enums, structs, and objects (instances of classes). And for good measure, you even have pointers to functions. You can ALSO have aliases (a.k.a. references?), but I won't go into detail about that one.

The * and & operators are what confuse me personally. They each have 2 meanings related to pointers, etc.

The first meaning comes when the operator follows a type:

int x;
int *y;
int &z = x;

In the above example we have an integer x, a pointer to an integer y, and an alias z to integer x (again, I will not discuss the alias).

If we want y to point to x, we must set it equal to the address of x using the address operator, &.

y = &x

Now, if we want to grab the value of x through the pointer y, we must use the indirection operator *.

*y = 3;

Now x == 3, *y == 3, and y == &x. Does that make sense?

Now for objects. C/C++ actually allows you to access data in structs and objects directly, as well as through pointers, as well as through pointers to pointers. Consider the following:

MyObj obj1; // declare a new object locally, or statically, or ....
MyObj *obj2Ptr = new MyObj(); // declare new object dynamically (on the heap)
// AND declare a pointer to it.

Now, where Java (and I think C#) uses the . operator to access members, C/C++ will use EITHER . -> or ::, depending on what it's accessing the object through.
. member of object
-> member of pointer's object (member of what the pointer is pointing to); this is a shortcut for *(ptr).member.
:: member of a class or namespace

e.g.
obj1.member;
obj2Ptr -> member;
*(obj2Ptr).member; // this is the same as the above line

SO, recognizing the difference between an object and a pointer to an object is CRUCIAL!!! I recommend using pointers to all your objects, and please BE CAREFUL not to modify the pointer unless you know what you're doing!!!