Arguments as pointer or address?

[MrPickle]

I am unclear on when an argument should be a pointer or an address? Aren't they the same, just the first is pointing to the address and the second is directly giving the address?

void foo(int* bar); //Pointer
void foo(int& bar); //Address?
 

[Ganon11]

Yes and no. They are both the same in the sense that, if I call one of your functions in main() with the variable myInt, any changes taking place in foo() will effect myInt, not just a copy. However, the way the functions deal with it (or rather, the way you as a programmer deal with the variable) are different.

In void foo(int *myInt) (using a pointer), you have a pointer to an int. That is, it's a pointer - you can dereference it, treat it as an array, tell it to point to a new variable, etc.

Your changes to myInt (that is, the pointer) are not reflected when foo() returns/finishes. Your changes to (*myInt) (that is, the integer pointed to by myInt) WILL be reflected when foo() returns/finishes.

In void foo(int &myInt) (using pass-by-reference), myInt is an int, NOT a pointer. You can't dereference it, or treat it as an array, or whatever.

Any changes you make to myInt (again, it's an int) are reflected when foo() returns/finishes.

So basically, when programming, you get a pointer when passing pointers, and you get an int when passing-by-reference.

(Internally, you're actually passing pointers in both situations, but with pass-by-reference, the computer takes a few extra steps for you so that you, the coder, can treat it as an integer).

[boxfish]

If you were to pass bar by value (no & or *), a copy of bar would be created. For larger bars, such as class types, this is a waste of time and space, but it means that the function cannot modify the original bar.
If you pass bar by pointer (with *), you have the benifit of not making a copy of bar (only the pointer gets copied), but your function will have to deal with awkward pointer syntax. Also, the function can modify the original bar.
Passing by reference (with &) is supposed to be the best of both worlds. You can't do it in C, only C++. You actually pass a pointer to bar, but it's behind the scenes. You use bar in your function just like you would if you had passed it by value, but it's not a copy of bar, so if you modify it, the original bar gets modified.
If you want to pass by reference to avoid copying bar, but want to ensure that your function doesn't modify bar, pass by constant reference, with const and &.
Passing by constant reference instead of passing by value saves time and space with objects that take up a lot of memory, but with little things like ints, just pass by value.

void foo(int bar); // By value
void foo(int* bar); // By pointer
void foo(int& bar); // By reference
void foo(const int& bar); // By constant reference.
 

[MrPickle]

Okay, I think I get it now, thanks!