Incrementing Pointers

Question

I have a question about incrementing in pointers that I dont quite understand.

Lets see 2 small programs:

int iTuna=1;
int* pPointer= &iTuna;
*pPointer = *pPointer + 1 ; //Increment what pPointer is pointing to.
cout << iTuna << endl;

In this first program I increment what pPointer is pointing to like this "*pPointer = *pPointer +1". And as I expected iTuna changed to "2" and the program printed out the value "2"

int iTuna=1;
int* pPointer= &iTuna;
*pPointer++; //Increment what pPointer is pointing to.
cout << iTuna << endl;
system("PAUSE");
return 0;

Here I incremented incremented what pPointer is pointing to this was "*pPointer++". But here iTuna stays as "1" and the programs prints out the value "1" . Although I expected this one to work as the first, it didn't.

Please Help me and tell me why the second peice of code isn't working like I expected and how to get around it.

Thank You

Answer 1

*pPointer++;

is equivalent to

*pPointer;
pPointer++; 

so it increments the pointer, not the dereferenced value.

You may see this from time to time in string copy implementations like

  while(*source)
    *target++ = *source++;

Since your problem is a matter of operator precedence, if you want to deref the pointer, and then increment, you can use parens:

(*pointer)++;

Answer 2

++ operator precedence is higher than *d dereference.

What you write is actually

*(p++)

However you should use

(*p)++

Answer 3

In the Second program you are not increasing the the content at the pPointer address, but you are increasing the pointer. So suppose here if the pPointer value(memmory location allocated to iTuna) is 1000 then it will increase the location to 1000+2(int size)=1002 not the content to 1+1=2. And In the above program you are accessing the pointer location contents. Thats why you are not getting the expected results

Answer 4

 *ptr++; - increment pointer and dereference old pointer value

It's equivalent to:

*(ptr_p++) - increment pointer and dereference old pointer value

Here is how increment the value

(*ptr)++; - increment value

That's becuase ++ has greater precedence than *, but you can control the precedence using ()

Answer 5

*pPointer++; - Here dereference operator(*) has more precedence than increment operator(++). So this statement is first dereferencing and incrementing the pointer. After this you are printing the value of iTuna which will give you the same value. You are not printing the value by dereferencing pointer variable(*pPointer), because this will leads to crash(undefined behaviour). Because pPointer is now incremented.

Use like (*pPointer)++; to increment the value which is pointed by pPointer.

To get clear idea print the address stored in pPointer variable before and after your increment statement.

Answer 6

In the first case, the content of the pointer is incremented because *pPointer correspond to the content of the variable iTuna.

In the second one, the content is not incremented because you pPointer incrementing the pointer address. Remembering operator precedence rules, postfix operators such as increment (++) and decrement (--), have higher precedence than prefix operators, such as the dereference operator (*). Therefore, writting

*pPointer++

is equivalent to

*(pPointer++)

And what it does is to increase the value of pPoiner (so it now points to the next element), but because ++ is used as postfix, the whole expression is evaluated as the value pointed originally by the pointer (the address it pointed to before being incremented).

The correct code to have what you are expecting for is the following:

++*pPointer

or

(*pPointer)++