Thread: Pointers and References

When you pass by reference or by pointer, you pass in the address of the object, because that's what gets stored in the functions parameters.

Compile this example if you need to see.

Code:

#include <iostream>

void f (int &passed_in) {
   std::cout << "The address of the object in f() is " << &passed_in << "\n";
}

int main() {
   int n = 42;
   std::cout << "The address of the object in main() is " << &n << "\n";
   f(n);
   return 0;
}

Well, in fact, when you pass by pointer, you are passing the address of an object but when you pass by reference, you are passing a reference to an object which is nearly the same as the object itself.

Gneh ! =)

It is legal, but it creates overhead.

A reference is treated like a pointer internally. So when a referenced variable is accessed, a pointer is dereferenced. This is usually less system intensive than copying the value over, but with objects as small as pointers, the oposite is true.

It is legal. But what does it yield?

Code:

int value = 26;        //ignore this one for now

int raw = 13;
int *ptr_raw = &raw;
int* &ref_ptr_raw = ptr_raw;

cout << "raw: " << raw << endl;
cout << "*ptr_raw " << ptr_raw << endl;
cout << "ref_ptr_raw " << ref_ptr_raw << endl;
cout << "&ref_ptr_raw " << &ref_ptr_raw << endl;

As you can see a reference to a pointer (ref_ptr_raw) yields the address of the pointer. It behaves exactly like a normal reference. In other words, it is just an alias of your pointer. You can use it to change your pointer...

Code:

int value = 26;   //Now using this one

int raw = 13;
int *ptr_raw = &raw;
int* &ref_ptr_raw = ptr_raw;

cout << "raw: " << raw << endl;
cout << "*ptr_raw " << ptr_raw << endl;
cout << "ref_ptr_raw " << ref_ptr_raw << endl;
cout << "&ref_ptr_raw " << &ref_ptr_raw << endl;

ref_ptr_raw = &value;
cout << "\nChanged: ref_ptr_raw = &value" << endl;
cout << "ref_ptr_raw " << ref_ptr_raw << endl;
cout << "&ref_ptr_raw " << &ref_ptr_raw << endl;

Notice how the syntax for the reference assignment is just the same as it is for pointers. That is because you can conceptually just look at your reference to a pointer as just another name for your pointer.
Let's change back. But this time we change the pointer directly. And not the reference...

Code:

int value = 26;

int raw = 13;
int *ptr_raw = &raw;
int* &ref_ptr_raw = ptr_raw;

cout << "raw: " << raw << endl;
cout << "*ptr_raw " << ptr_raw << endl;
cout << "ref_ptr_raw " << ref_ptr_raw << endl;
cout << "&ref_ptr_raw " << &ref_ptr_raw << endl;

ref_ptr_raw = &value;
cout << "\nChanged: ref_ptr_raw = &value" << endl;
cout << "ref_ptr_raw " << ref_ptr_raw << endl;
cout << "&ref_ptr_raw " << &ref_ptr_raw << endl;

ptr_raw = &raw;
cout << "\nChanged: ptr_raw = &raw" << endl;
cout << "ref_ptr_raw " << ref_ptr_raw << endl;
cout << "&ref_ptr_raw " << &ref_ptr_raw << endl;

See how the pointer now points back to raw and the reference "followed"? You now have the same output as in the beginning.

A reference to a pointer can be (and is) used. Some care though must be given to special cases like the one grumpy mentioned.

I really suggest you get used to put the pointer operand either immediatly after the type or just before the object name. It makes for more readable code. As you have it, it's confusing. It looks like you are multiplying instead of declaring a pointer.

int* ptr = &obj;
or
int *ptr = &obj;

Both forms are more common. However, int * ptr = & obj while valid, is confusing. But even more so when defining functions like the one above.

As a side note if you decide to stick to int* ptr, do not declare more than one pointer per line. Personally I prefer this form because it makes it more visible that I am declaring a pointer to int. However,

int* ptr, ptr2;

ptr2 is not a pointer to int, even though one might be lead to believe so at first glance. It is instead an int. The correct would have been int* ptr, *ptr2;. But this is slightly confusing too. Best option is to declare one pointer per line. Or use the other form...

int* ptr;
int* ptr2;

or

int *ptr, *ptr2;

As for your question, this call here GenericNodeToBinaryNode (node, BinNode); is ambiguous. The arguments you are passing didn't allow the compiler to choose exactly which of the versions of GenericNodeToBinaryNode() it should use. Check your arguments types and the function definitions.

But it has only one definit... wait... OK, I got it. This implementation is a group work I'm making with some friends, and I'm keeping the prototypes at the beginning of the .cpp, so we only need to send one file to each other and it still makes it easy to, after it's all done, split the file into a .cpp and a .h. What happened is, I forgot to change the prototype... I feel so dumb now...