Why is the address of the variable increased instead of its value?

Question

0.00/5 (No votes)

See more:

I appreciate if someone knowledgeable describes why in the expressions like *p++ the pointer's value changes?

#include <stdio.h>

int main(void) {
    int a=1,*p;
    p=&a;
    printf("The original Addres=%p and a= %d\n",p,a);
    a=(*p)++;
    printf ("The second Address=%p and a=%d",p,a);
}

What I have tried:

even in *p++; the pointer' value is chaned rather than the varianle's value.

Posted 24-Feb-23 6:07am

Ehsan Nazeri

Updated 24-Feb-23 10:31am

v2

Add a Solution

3 solutions

Add a Solution

This content, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)

Richard MacCutchan · Answer 1 · 2023-02-24T06:34:00

Solution 1

In the code you have posted the address of p remains constant.

C++

a = (*p)++;

The reason is that the above statement says:
- take the value stored in p and increment it by one
- then save the resultant value in variable a
*** see latest comments below.
In this case the value of p's address does not change.

If you change the code to:

C++

a = *p++;

then p will increase, but a will not, as this statement says:
- take the value stored in p and copy it into variable a
- then increment the address of p

[edit]
As pointed out by 0x01AA my answer for the first case is incorrect. I have run further tests and it appears that the Microsoft compiler may have a bug as it incorrectly stores the incremented value of the variable. I have double checked with the assembler output and the generated code is definitely wrong.
I will raise a bug report with Microsoft.
[edit]

Posted 24-Feb-23 6:34am

Richard MacCutchan

Updated 26-Feb-23 2:17am

v2

Comments

0x01AA 24-Feb-23 13:55pm

Not really correct and no vote from my side! a = (*p)++; means
assign the value stored in p and afterwards increment the value stored on p.... and that increment disapears then in the nirvana ;)

Richard MacCutchan 25-Feb-23 3:48am

I am not sure I understand what you are saying, but my answer is based on running both versions of the code, and hence is correct.

0x01AA 25-Feb-23 11:46am

I'm only on the first case a = (*p)++;

You wrote
- take the value stored in p and increment it by one
- then save the resultant value in variable a

But it is, because post increment
- take the value stored in p and assign it to a
- then increment the value (*p), which at least with my compiler does nothing.

Not a thing to worry about I think ;)

Richard MacCutchan 26-Feb-23 3:17am

You are correct, but only partly. If I run this code in a pure C program I get the following result:

The original Addres=000000E21EDFF774 and a= 1
The second Address=000000E21EDFF774 and a=2

But if I run it in a C++ program I get a different (correct?) result:

The original Addres=0000007B1A2FFC84 and a= 1
The second Address=0000007B1A2FFC84 and a=1

So it looks like C code treats that expression differently. I will have to dust off my K&R to see why.

0x01AA 26-Feb-23 5:07am

Thank you very much for your feedback.
I tested it indeed with c++. So have my 5 then.

Richard MacCutchan 26-Feb-23 8:12am

Thank you, but I think this is actually a Microsoft bug. I have just tested the same cod using the GNU compiler and the results is correct. I should have spotted this myself, so will make obeisance to the great god of C.

CPallini · Answer 2 · 2023-02-24T08:13:00

The following piece of code, similar to your program:

C

#include <stdio.h>

int main()
{
    int a=1,*p;
    p=&a; // here 'p' points to 'a', that is 'p' contains the address of 'a'

    printf("p = %p, a = %d \n", p, a);

    a=(*p)++; // this means: take the value pointed by p, assign it to a, and eventually increment it.
              // i.e. equivalent to the sequence:
              //   a = a;
              //   (a+1);
              // having no effect.

    printf("then\np = %p, a = %d \n", p, a);

    return 0;
}

produces on my system:

p = 0x7ffe47db05bc, a = 1 
then
p = 0x7ffe47db05bc, a = 1

(No changes)

While this one

C

#include <stdio.h>

int main()
{
    int a=1,*p;
    p=&a; // here 'p' points to 'a', that is 'p' contains the address of 'a'

    printf("p = %p, a = %d \n", p, a);

    a=*p++; // this means: take the value pointed by p, assign it to a, and eventually increment p.
              // i.e. equivalent to the sequence:
              //   a = a;
              //   p = &a + sizeof(a)
              //
    printf("then\np = %p, a = %d \n", p, a);

    return 0;
}

produces

p = 0x7fff71b6233c, a = 1 
then
p = 0x7fff71b62340, a = 1

(the value of p changed)

Finally, this one

C

#include <stdio.h>

int main()
{
    int a=1,*p;
    p=&a; // here 'p' points to 'a', that is 'p' contains the address of 'a'

    printf("p = %p, a = %d \n", p, a);

    a=++(*p); // this means: take the value pointed by p, increment it, assign it to a.
              // i.e. equivalent to the statement:
              //   a = a + 1;

    printf("then\np = %p, a = %d \n", p, a);

    return 0;
}

produces

p = 0x7ffee94b2e2c, a = 1 
then
p = 0x7ffee94b2e2c, a = 2

(the value of a changed)

k5054 · Answer 3 · 2023-02-24T06:50:00

There's two things going on here. The first is operator precedence, and the second is postincrement.

C

 // the expression:
a = *p++;
// is equivalent to
a = *p;  // dereference p 
p += 1;  // increment p after access
         // Note that now dereferncing p invokes undefined behavior

// If you want to increment what p is pointing to without moving it then you want
a = ++(*p);
// Note that as the source and destination are the same address, I think it is undefined as
// to what gets assigned to a.  It's much better in this case to do
a = *p + 1;
// as that will not invoke undefined behavior.

Why is the address of the variable increased instead of its value?

3 solutions

Solution 1

Solution 3

Solution 2

Add your solution here

Preview 0

Why is the address of the variable increased instead of its value?

3 solutions

Solution 1

Solution 3

Solution 2

Add your solution here

Preview 0

Existing Members

...or Join us