changing the adress of the pointer through another pointer

Question

Heloo GUYS ..I am passing an alias to pointer in function and in that function i am assigning pointer to another variable .This is changing the address of the pointer passed in main funtion .i'll show u example of my code .This gives the output 40.

#include <iostream>
using namespace std;
void foo(int* &p){
    int z=40;
    p=&z;
}
int main(){
    int x=10;
    int *p=&x;  
    foo(p);
    cout<<*p;
}

But when I try to do this all in one main function then the address of the the pointer doesnt change so as the ouput..this is my code

#include<iostream>
using namespace std;
int main()
    {
       int a=1, b=2, c=3;
       int *p, *q;
       p=&a;
       q=*&p;
       p=&c;
       cout<<*q<<endl;

    }

it gives the ouput 1 rather then the 3.THANKs..

That's because you aren't changing `q`. You are changing `p`. — NathanOliver, May 22 '15 at 14:16
c++ doesn't time travel. just because you do `p=&c` doesn't change the fact that `q` ended up pointing at `a`'s value in the previous line. — Marc B, May 22 '15 at 14:20
If you want to do "the same", it would look more like this: `int* p = &a; int*& q = p; q = &c; cout << *p;`. — molbdnilo, May 22 '15 at 14:24

Drax · Answer 1 · 2015-05-22T14:31:16.807

void foo(int* &p){
    int z=40;
    p=&z;
}

Here pis a reference to a pointer. Which means that when you modify it you will modify the referred pointer too.

When you call foo with

int main(){
    int x=10;
    int *p=&x;  
    foo(p);
    cout<<*p;
}

You're saying that the reference named pin the function foo refers to the pointer named pin the function mainso whatever you do to p in foowill affect p in main.

#include<iostream>
using namespace std;
int main()
    {
       int a=1, b=2, c=3;
       int *p, *q;
       p=&a;
       q=*&p;
       p=&c;
       cout<<*q<<endl;

    }

Here you have no reference anywhere, you just have a pointer that you copy to another pointer. q=*&pis equivalent to q=p.

The key difference to note here is that the & operator in the first exemple means "reference" while the & operator in the second example means "address of".

If you want the closest equivalent to the first sample with the second one, try this:

#include<iostream>
using namespace std;
int main()
{
  int a=1, b=2, c=3;
  int *p, *&q = p;
  p=&a;
  q=*&p;
  p=&c;
  cout<<*q<<endl;

}

And in this last case you have both an & which means "reference" in int *p, *&q = p; and an & that means "address of" in q=*&p;

score 0 · Answer 2 · answered May 22 '15 at 14:17

void foo(int* &p){
    int z=40;
    p=&z;
}

The above code is not safe because whoever called foo now has a pointer to a destroyed stack variable.

it gives the ouput 1 rather then the 3.THANKs..

Of course it does. Learn what a pointer is and how it works.

int a=1, b=2, c=3, *p, **q;
p=&a;
q=&p;
p=&c;
std::cout << **q << std::endl;

score 0 · Answer 3 · answered May 22 '15 at 14:17

just thought you should know that in foo() you're assigning the pointer to the address of a variable with automatic storage duration, which means that what it points to when foo returns is actually undefined (and in a larger program this is a disaster waiting to happen).

In your second example you only assign q once. During an assignment, a reference is the object it's referring to. The reference dependency is not carried forward.

score 0 · Answer 4 · edited May 23 '17 at 12:30

That's because you aren't changing q. You are changing p. When you do

q=*&p;

it is the same as

q = p;

So what you have done is assigned p to point to a. Then you assign the value of p to q so now q points to a. Then you assign the address of c to p. Doing that does nothing to q and as such q still points to a.

You should also read Can a local variable's memory be accessed outside its scope? to see why your first example has undefined behavior.

score 0 · Answer 5 · answered May 22 '15 at 14:22

0

Why do you expect to get the answer as 3?

enter image description here

q points to p then you changed where p points. p points to c but q will still point to where previous address of p.

unless you reassign q to point to p, it will still point to a.

answered May 22 '15 at 14:22

sam

2,033
2
10
13

score 0 · Answer 6 · answered May 22 '15 at 14:27

Let me only consider your second example and I added a few comments and hopefully it will clarify why you are getting that output.

   int a=1, b=2, c=3;
   int *p, *q;
   p=&a; //P now points to the variable a
   q=*&p; // q now points to the value in pointer p
   p=&c;
   cout<<*q<<endl; //You are printing  value from pointer q

Please note you are not changing the address of a pointer, instead you are changing only the address where pointer points to.

changing the adress of the pointer through another pointer

6 Answers6