将指针地址与指针传递给C中的指针

Question

I'm slightly confused between these two pieces of code:

version 1: (gives warnings after compiling)

int func(int *ptr2)
{
    *ptr2 += 1;
}

int main()
{
    int a = 5;
    int *ptr = &a;

    printf("Address of a: %x\n", a);
    printf("Before: %x\n", ptr);
    func(&ptr);
    printf("After: %x\n", ptr);
    return 0;
}

Output:

Address of a: 5770a18c
Before: 5770a18c                                                                                                           
After: 5770a18d 

version 2:

int func(int **ptr2)
{
    *ptr2 += 1;
}

int main()
{
    int a = 5;
    int *ptr = &a;

    printf("address of a: %x\n", &a);
    printf("Before: %x\n", ptr);
    func(&ptr);
    printf("After: %x\n", ptr);
    return 0;
}

Output:

Address of a: cc29385c
Before: cc29385c                                                                                                           
After: cc293860

If I'm understanding pointers in C correctly when we pass by reference, we are creating a pointer to that location. This allows us to change the value at the address held by the pointer through the dereference operator.

However, if we want to change the value held by a pointer, we use a pointer to a pointer. We pass the address of the pointer and create a new pointer to hold said address. If we want to change the value, we use the dereference operator to access our pointer's (defined elsewhere) value.

Hopefully I'm on the right track, but I'm struggling to visualize what's happening with version 1 specifically. Mainly, I'd just like to understand the difference in make-up and output between these two programs. I assume version 1 is still a pointer to a pointer, but why are the incremented values different between both programs? If version 1 is successfully incrementing ptr's value (which I suspect is not), why is that I cannot find code with the same syntax? I think I'm missing something fairly trivial here... Any help is appreciated

Answer 1

Based on your output, you appear to be compiling for a 32-bit system where addresses and int are of that size.

When you increment the value at *ptr with that type being int , it will simply add 1.

When *ptr resolves to an int* then it will increment by sizeof(int) because the value at the current address in this case is 4 bytes long, so we have to increase the address by the number of bytes that an int consumes so that we're pointing at the next int. Note that doing this is only valid if you actually have allocated memory at the subsequent address.

Generally you pass a T** when the callee needs to modify the address to point to - such as say, the callee performs a malloc() to allocate space for the pointer.

Answer 2

&ptr is a pointer to a pointer, but what is passed to func() is a pointer to int converted from &ptr in implementation-defined manner. Then, *ptr2 += 1; is incrementing int and add 1 to what is pointed by ptr2 (the pointer ptr in main() , which eventually have the same reepresentation as `int in your system).

In version 2, the pointer to a pointer is correctly passed to func() . Therefore, pointer aritimetic is performed and the size of int is added to the address.

Note that you invoked undefined behavior by passing data having wrong type to printf() . The correct way to print pointers is like this:

printf("Before: %p\n", (void*)ptr);

As you see, cast the pointer to void* and use %p specifier.