CODEWITHSUNDEEP
cpointersstruct
java
java

Reputation: 1165

Change passed pointer in function

Concerning double indirection (pointer to pointer) and passing those to a function

I cannot change the pointer here in function void test(int **nmbr, int *n);

int n = 5;
int n2 = 555;   

int *nPtr = &n;
int *n2Ptr = &n2;

printf("the number = %d\n", *nPtr);

test(&nPtr, n2Ptr);

printf("the number is now = %d\n", *nPtr);

test

void test(int **nPptr, int *n2Ptr) {

 int *p = *nPptr;

 p = n2Ptr;

}

since the pointer p points to a copy of *nPtr, right?

But what about this code (this time the pointer points to a given struct in a linkedlist

the code snipped is from the site https://www.learn-c.org/en/Linked_lists

 int remove_by_index(Person **head, int n) {
int i = 0;
int retval = -1;
Person *current = *head;
Person *temp_node = NULL;

if (n == 0) {
    return pop_first(head);
}

for (i = 0; i < n-1; i++) {
    if (current->next == NULL) {
        return -1;
    }
    current = current->next;
}

temp_node = current->next;
retval = temp_node->nmbr;
current->next = temp_node->next;
free(temp_node);

return retval;

}

it removes a given node in the list by a given indexnumber

Here one can see that *current is local copy in the function and traversate in the list and lastly merges two nodes, without problem

So why does it work to change the pointer here but not in the function test(int **nPptr, int *n2Ptr)?

To be clear

in the function test:

 int *p = *nPptr;

p is local copy and copies the pointer from *nPtr

in the function remove_by_index

Person *current = *head;

current is local copy and copies the pointer from *head. The list lives beyond the scope of the function remove_by_index(..) so I do not understand why it can be manipulated in the function by the local pointer *current, at the same time as it does not work to alter nPtr in function test(..)

Upvotes: 2

Views: 792

Answers (1)

Ian Abbott
Ian Abbott

Reputation: 17503

In a function, changes to pointer variables or pointer parameters have no effect outside the function. However, if the pointer is pointing to an object outside the function, that object can be modified by dereferencing the pointer.

For example, in OP's test function:

void test(int **nPptr, int *n2Ptr) {
    int *p = *nPptr;

    p = n2Ptr;
}

p is initialized and then its value is changed by an assignment. This has no effect on any object outside the function. If the function were changed as follows:

void test(int **nPptr, int *n2Ptr) {
    int *p = *nPptr;

    p = n2Ptr;

    *nPptr = p;
    *p = 42;
}

Then two objects outside the function will have been modified (an int * and an int).

In OP's remove_by_index function, changes to the current variable as it progresses through the linked list have no external effect, but the line:

current->next = temp_node->next;

is equivalent to:

(*current).next = (*temp_node).next;

The external Person object that current is pointing to on the linked list has been modified by dereferencing of the pointer and assignment to the next member of the Person it is pointing to.

Upvotes: 2

Related Questions