通过另一个指针更改指针的地址

Question

Heloo GUYS ..我在函数中传递别名到指针，在该函数中我指定另一个变量的指针。这是改变主要功能中传递的指针的地址。我将展示你的代码示例这给出了输出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;
}

但是当我尝试在一个主函数中执行此操作时，指针的地址不会改变，因此输出...这是我的代码

#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;

    } 

它给出了输出1而不是3.THANKs ..

Answer 1

    var animation1 = CABasicAnimation(keyPath: "opacity")
    // Don't go back to the initial state after the animation.
    animation1.fillMode = kCAFillModeForwards
    animation1.removedOnCompletion = false

    // Set the initial and final states of the animation.
    animation1.fromValue = 0
    animation1.toValue = 1

    // Duration of the animation.
    animation1.duration = 1.0


    var animation2 = CABasicAnimation(keyPath: "opacity")
    animation2.fillMode = kCAFillModeForwards
    animation2.removedOnCompletion = false

    animation2.fromValue = 0
    animation2.toValue = 1

    animation2.duration = 1.0

    // Add a 0.5 second delay.
    animation2.beginTime = CACurrentMediaTime() + 0.5

    // Animate!
    backgroundLayer.addAnimation(animation1, forKey: "opacity")
    backgroundLayer2.addAnimation(animation2, forKey: "opacity")

此处Login是指针的引用。这意味着当你修改它时，你也会修改引用的指针。

使用

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

p

您说函数foo中名为int main(){ int x=10; int *p=&x; foo(p); cout<<*p; } 的引用引用函数p中名为foo的指针，因此无论您对p中的main所做的一切都会影响p中的foo。

p

这里你没有任何参考，你只有一个指针，你复制到另一个指针。 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; } 。

这里要注意的关键区别是第一个例子中的q=*&p运算符表示“引用”，而第二个示例中的q=p运算符表示“地址”。

如果你想要第一个样本与第二个样本最接近的等价物，试试这个：

&

在最后一种情况下，&代表#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; } 中的“引用”，&代表int *p, *&q = p;中的“地址”

Answer 2

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

上面的代码不安全，因为现在调用foo的人都有一个指向已销毁堆栈变量的指针。

  

它给出了输出1而不是3.THANKs ..

当然可以。了解指针是什么以及它是如何工作的。

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

Answer 3

只是认为你应该知道在foo（）中你将指针分配给具有自动存储持续时间的变量的地址，这意味着它在foo返回时指向的内容实际上是未定义的（并且在更大的位置）程序这是一场等待发生的灾难。）

在第二个示例中，您只需指定q一次。在分配期间，引用是它所引用的对象。引用依赖关系不会继续使用。

Answer 4

那是因为你没有改变q。您正在更改p。当你这样做

q=*&p;

与

相同

q = p;

因此，您所做的工作已指定p指向a。然后，您将p的值分配给q，现在q指向a。然后，您将c的地址指定给p。这样做对q无效，因此q仍然指向a。

您还应该阅读Can a local variable's memory be accessed outside its scope?，了解为什么您的第一个示例有未定义的行为。

Answer 5

为什么您希望得到3的答案？

q指向p，然后您更改了p点的位置。 p指向c，但q仍会指向p之前的地址。

除非您重新指定q指向p，否则仍会指向a。

Answer 6

让我只考虑你的第二个例子，我添加了一些评论，希望它会澄清你为什么得到那个输出。

   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

请注意，您没有更改指针的地址，而只是更改指针所指向的地址。