无法理解涉及指针的C程序的一小部分

Question

int x = 5;
int y = 6;
int *p = &x;
*p = x + y;
p = &y;
*p = x + y;
printf("%d,%d", x, y);

I can understand the first 3 lines. I know that int *p = &x; means that the pointer p is pointing at the memory address of x . But I can't understand the next 4 lines of the code. The output for this code is:

 11,17

But I unable to understand how? Can someone explain it to me.

Answer 1

A pointer is a variable whose value is the address of another variable, ie, direct address of the memory location.

When you are assigning like this,

 int *p=&x;// It will point to the address of x variable. 

Any change done in the *p , It will affect the memory. So while you are accessing that with the x it have the value.

 *p=x+y; // It's equivalent x=x+y;

Then y also like this.

Now x have the value 11 . p=&y;

  *p=x+y;// It's equivalent to y=x+y;

so now x have the value 11 and y value 5 . So the result is 17 .

Answer 2

Let's analyze the code line by line, shall we?

Before going into the answer, a small info, * is called the indirection or dereference operator, which is used to access the value at a memory address .

So, per your code:

• *p = x + y; add x and y and store the value at the memory location pointed by p ^{[ie the address of x ].} . So, this way, the actual value of x is getting modified. now, x holds x+y or 5+6 or 11 .

• p = &y; same logic as int *p = &x;

• *p = x + y; same logic as the first point. remember, x value got modified in the first occasion, so the latest x value will be considered. So, modified y will be 11 + 6 or 17 .

• printf("%d,%d", x, y); Now don't tell me you did not understand this line. :-)

Answer 3

      *p = x + y; 

So now p will point the address of x, and (*p) will point the value stored in the x. so your changing the value of x , in its memory location.

       p = &y;

Now your assigning the address of y to p.

       *p = x + y;

Now you change the value of y using its memory address.

Answer 4

In fact this code snippet

int x = 5;
int y = 6;
int *p = &x;
*p = x + y;
p = &y;
*p = x + y;
printf("%d,%d", x, y);

you may rewrite the following way without using pointers that it would be more clear

int x = 5;
int y = 6;
x = x + y;
y = x + y;
printf("%d,%d", x, y);

So at first x is set to the sum of x + y and will be equal to 11 and then y is set to the sum of updated x (that now is equal to 11) and y and will be equal to 17 .

The only difference that instead of using directly x and y the first code snippet uses pointers.

Thus

statement x = x + y; is replaced with combination of these two statements

int *p = &x;
*p = x + y;

and statement

y = x + y;

is replaced with combination of these two statements

p = &y;
*p = x + y;

That is at first pointer p is assigned the address of x

int *p = &x;

and the object (that is x) is assigned the sum of x + y

*p = x + y;

The same is repeated for varaiable y and pointer p.

Answer 5

*p = x + y

Dereference pointer p, assign value of x + y to the memory that p is pointing to. Equivalent to x = x + y . x is equal to x + y now, which is 5 + 6 = 11 .

p = &y

Assign the the address of y to pointer p. Pointer p points to memory of y in other word.

*p = x +y

Dereference pointer p, assign value of x + y to the memory that p is pointing to. Equivalent to y = x + y . y is equal to x + y now, which is 11 + 6 = 17 .

At the end, x = 11 , y = 17 .

Hope it helps.

Answer 6

To better understand pointers and related ampersand and asterisk symbols i propose to this basic statements:
lets assume:

int * p;
int x;

1) Pointer is an address. That means that in p is an address in memory where integer value is stored
2) when *p is used the asterisk symbol can be "translated" as "value at the address"; This means that when we used *p we want take a value that resides in address p;
3) when &x is used the ampersand symbol can be "translated" as "address of"; This means that we want to take address of x;

thus operations:
0) p = x; would not be correct;
1) *p = x; is correct (if p is a valid address) and value at address p is now same as value x;
2) p = &x; is correct, and *p == x; in this case also you need to understand, that p and &x is the same address. so if you change either *p or x, the other one will have same value as well.