Is this C code wrong?

Question

I know that pointers contain the addresses of variables, for example:

int c = 5;
int *p;  
p = &c;
printf("%d",*p); // Outputs 5.

But what if I want to send an address to a function:

void function (int *p)
{
  p++;
}
int c;
function (&c);

When function is called, the value of &c is assigned to int *p. I guess that the exact instruction is: *p = &c;, but I don't understand what this means.

Answer 1

I prefer to write int* p = &c;, that is, a pointer to type int is being assigned the address of c.

Pointer notation can be confusing, as you've noticed, because these two are equivalent:

int *p = &c;

and

int *p;
p = &c;

Hope this helps!

EDIT: The confusion comes because * is used both as the dereference operator, and for declaring a pointer. So when p contains the address of c, *p dereferences the pointer and returns the value of c. But when you say int *p = &c;, the * is saying "p is a pointer to an int", but is not doing any dereferencing.

Answer 2

Are you sure p++; is what you mean to do in your function? That's incrementing the location pointed to by p, it's not incrementing the value at the current location. If you're wanting to increment the value (i.e. make c become 6), then what you want is (*p)++;.

Answer 3

If you want the function to increment c when called with &c, then write this:

void function(int *p) { ++(*p); }

function(int *p) means that p is the function parameter. So whatever value the caller gives, that will be assigned to p (not to *p).

The type of p is int *. That is, p is a pointer-to-int.

If p is a pointer-to-int, then *p is the int it points to.

c is an int. Therefore &c is a pointer-to-int, and the int it points to is c. Therefore, if p is &c, then *p is c.

With my version of the function, this code:

int c = 5;
function(&c);

Does the same as this code:

int c = 5; // same as before
int *p;    // parameter of the function
p = &c;    // assign the caller's value to the parameter
++(*p);    // body of the function, increments *p, which is the same as c.

Which does the same as this code:

int c = 5;
++c;

Answer 4

I can't really make out your question, but the function looks like bug to me and what you meant is, perhaps,

++(*p)

Otherwise it's a no-op.

Answer 5

Others have answered your question. I will just add that a helpful way of reading pointer declarations is this. Let's say I have the following declaration:

int i;

This is really easy. Here, i is an int. Now, let's say I have this:

int *pi;

Here, you can either say that pi is a pointer to an int (which is correct). Another way to look at it would be that *pi is an int, i.e., when you have *pi in your code, that *pi will be of type int. Having understood that, I think it's easy to see that ++pi or pi++ doesn't increment the int, because pi is the wrong type. You want (*pi)++. The parentheses are needed because in C, the operator ++ has higher precedence than the unary operator *. Since you don't use any of the side effects of the increment, you can as well do: ++*p.

Of course, as with all the pointers, pi has to point to something useful for the above to make sense.