Thread: passing pointer vs passing address of pointer

In the first case the modification of head inside the loop does not modify what head points to outside the loop. In the second case, when the function exits you will actually have modified what the pointer used as argument points to.

Run the following and you will see that at "THIRD *p" you will have changed p in main to point to global2.

Code:

#include <iostream>
int global1 = 10, global2 = 20;

void printLL(int* p) {
    std::cout << "Pointer: " << *p << std::endl;
    p = &global2; // This has no effect
}

// compare to

void printLL2(int*& p) {
    std::cout << "Reference to pointer: " << *p << std::endl;
    p = &global2; // p in main will now continue to point to global2
}

int main()
{
    std::cout << "global1: " << global1 << std::endl;
    std::cout << "global2: " << global2 << std::endl;

    int *p = &global1;
    std::cout << "FIRST *p: " << *p << std::endl;
    printLL(p);
    std::cout << "SECOND *p: " << *p << std::endl;
    printLL2(p);
    std::cout << "THIRD *p: " << *p << std::endl;
}

Originally Posted by googol

passing pointer vs passing address of pointer
(...)
I was encouraged to be aware of the difference between passing Node* head, and Node*& head

In neither case do you pass the address of the pointer. In the former, you pass the pointer by value. In the latter, you pass the pointer by reference, or we can say that a reference parameter was used. It may be the case that to implement this aliasing the compiler uses what amounts to a pointer to the pointer, but that is up to the implementation.

Originally Posted by googol

have experimented a bit and often times the function still does the same thing regardless of which I use. For example the print function runs the same both ways.

You will notice the difference should you modify the parameter. For example, call your print function twice in a row. You will find that with your Node* head version, the linked list will be printed twice. With your Node*& head version, the linked list will be printed once. This is because for the Node* version, assigning to head only changes the local copy of the pointer. For the Node*& version, head is an alias of the argument from the caller, so assigning to head locally also changes the original from the caller.

Take a look at this pointer tutorial. That should help clear some things up for you. Also if you are doing linked list implementation, this is a good resource.