While browsing some sample code recently, I encountered the following C language expression:

x = &(*ptr);

Both variables x and ptr are pointers. So what the heck is going on?

Often I copy a sample program from the Internet to see what it does. Because I typically don’t like the way the coder presents things (often because not everyone really understands pointers), I work with the code, modify it, and eventually concoct my own version.

In this instance, I dutifully copied the code, which dealt with reading data from a PNG image file. From the sample line above, the ptr variable references an array of pointers. So it can be declared as:

**ptr

Or:

*ptr[]

I use the latter format in my code, though I may change it to the ** format after I fully grasp what’s going on. In this case, the variable x (in my example) is pulling an address from one of the pointers (memory locations) stored in the ptr array. But what the heck is &(*ptr)? It looks terribly confusing.

My assumption was that the & and * operators canceled each other out, but I wasn’t sure. Though I enjoy using pointers and try to fully understand them, this notation befuddled me. So, I wrote this code to help unravel the mystery:

#include <stdio.h>

int main()
{
    char z,*p;

    z = 'A';
    p = &z;

    printf("%p == %p\n",p,&z);
    printf("%c == %c\n",*p,z);
    printf("&(*p) = %p\n",&(*p));

    return(0);
}

It’s best to explain what’s going on by viewing the output:

0x7ffee6841a6b == 0x7ffee6841a6b
A == A
&(*p) = 0x7ffee6841a6b

The first line compares the values of pointer variable p, which is assigned to the address of variable z, with the address of variable z directly. The values should be equal, and they are.

The second line compares the contents of each variable, first z directly and then z as referenced by variable p. Both are identical.

Finally, I perform the weirdo &(*p) operation on variable p. The result is the address of variable z, which is the original contents of variable p.

Because of these results, I confirmed my hypothesis that the & and the * operators cancel each other out.

Back in my PNG-reading program I edited the original statement to remove the redundancies.

The only puzzle that remains is how someone would think to use &(*p) as an operation in the first place? It could have been the result of a search-and-replace in the code. It could have been bad documentation at some point. Or, most likely, it could be yet another C programmer who doesn’t fully understand pointers and who piled on the operators and was fortunate enough to get the result he needed.

Pointers are mysterious and troubling to many coders. Yet apparently, some are bold enough to try this or that and publish the success on the Internet without ever fully understanding what’s going on. I hope you reach the point in your C programming career where you don’t have to do that.