如何更改 C++ 的变量参考是指？

Question

如果我有这个：

int a = 2;
int b = 4;
int &ref = a;

如何使 ref 在此代码之后引用 b ？

Answer 1

这是不可能的，这是设计使然的。引用不能反弹。

Answer 2

在 C++11 中，出现了新的 std::reference_wrapper。

#include <functional>

int main() {
  int a = 2;
  int b = 4;
  auto ref = std::ref(a);
  //std::reference_wrapper<int> ref = std::ref(a); <- Or with the type specified
  ref = std::ref(b);
}

这对于在容器中存储引用也很有用。

Answer 3

您无法重新分配引用，但如果您正在寻找提供与此类似功能的东西，您可以使用指针代替。

int a = 2;
int b = 4;
int* ptr = &a;  //ptr points to memory location of a.
ptr = &b;       //ptr points to memory location of b now.

您可以使用以下方式获取或设置指针内的值：

*ptr = 5;     //set
int c = *ptr; //get

Answer 4

从形式上来说，这是不可能的，因为这是设计所禁止的。实际上，如果你想破解它，这是可能的。

引用存储为指针，因此只要您知道如何获取其地址，就可以随时更改它指向的位置。同样，当您无权访问时，您也可以更改 const 变量、const 成员变量甚至私有成员变量的值。

例如，以下代码更改了类 A 的 const 私有成员引用：

#include <iostream>
using namespace std;

class A{
private:
    const int &i1;
public:
    A(int &a):i1(a){}
    int geti(){return i1;}
    int *getip(){return (int*)&i1;}
};

int main(int argc, char *argv[]){
    int i=5, j=10;
    A a(i);
    cout << "before change:" << endl;
    cout << "&a.i1=" << a.getip() << " &i=" << &i << " &j="<< &j << endl;
    cout << "i=" << i << " j=" <<j<< " a.i1=" << a.geti() << endl;
    i=6; cout << "setting i to 6" << endl;
    cout << "i=" << i << " j=" <<j<< " a.i1=" << a.geti() << endl;

    *(int**)&a = &j; // the key step that changes A's member reference

    cout << endl << "after change:" << endl;
    cout << "&a.i1=" << a.getip() << " &i=" << &i << " &j="<< &j << endl;
    cout << "i=" << i << " j=" <<j<< " a.i1=" << a.geti() << endl;
    j=11; cout << "setting j to 11" << endl;
    cout << "i=" << i << " j=" <<j<< " a.i1=" << a.geti() << endl;
    return  0;
}

程序输出：

before change:
&a.i1=0x7fff1b624140 &i=0x7fff1b624140 &j=0x7fff1b624150
i=5 j=10 a.i1=5
setting i to 6
i=6 j=10 a.i1=6

after change:
&a.i1=0x7fff1b624150 &i=0x7fff1b624140 &j=0x7fff1b624150
i=6 j=10 a.i1=10
setting j to 11
i=6 j=11 a.i1=11

可以看到 a.i1 最初指向 i，更改后，它指向j。

然而，这样做被认为是危险的，因此不推荐，因为它违背了参考的最初目的。 C/C++语言中reference的设计目的是禁止在编程层面改变其内容。因此，如果最终您需要更改其值，那么您应该考虑将该变量定义为指针。此外，这里提出的解决方案假设引用被实现为指针（在大多数编译器实现中都是如此，但不是全部）。因此，当底层实现不是指针时，它将不起作用（在这种情况下会导致程序崩溃）。

Answer 5

您无法重新分配参考。

Answer 6

以你想要的方式这是不可能的。 C++ 只是不允许您重新绑定引用所指向的内容。

然而，如果你想使用欺骗，你几乎可以用一个新的范围来模拟它（永远在真实的程序中这样做）：

int a = 2;
int b = 4;
int &ref = a;

{
    int& ref = b; // Shadows the original ref so everything inside this { } refers to `ref` as `b` now.
}

Answer 7

您可以使用新的放置非常容易地创建参考包装器：

template< class T >
class RefWrapper
{
public:
    RefWrapper( T& v ) : m_v( v ){}

    operator T&(){ return m_v; }
    T& operator=( const T& a ){ m_v = a; return m_v;}
    //...... //
    void remap( T& v )
    {
        //re-map  reference
        new (this) RefWrapper(v);
    }

private:
    T& m_v;
};


 int32 a = 0;
 int32 b = 0;
 RefWrapper< int > r( a );

 r = 1; // a = 1 now
 r.remap( b );
 r = 2; // b = 2 now

Answer 8

这是可能的。因为在底层，引用是一个指针。
以下代码将打印“hello world”

#include "stdlib.h"
#include "stdio.h"
#include <string>

using namespace std;

class ReferenceChange
{
public:
    size_t otherVariable;
    string& ref;

    ReferenceChange() : ref(*((string*)NULL)) {}

    void setRef(string& str) {
        *(&this->otherVariable + 1) = (size_t)&str;
    }
};

void main()
{
    string a("hello");
    string b("world");

    ReferenceChange rc;

    rc.setRef(a);
    printf("%s ", rc.ref.c_str());

    rc.setRef(b);
    printf("%s\n", rc.ref.c_str());
}

Answer 9

正如其他答案所说，这是不可能的。

但是，如果您将引用存储在 class 或 struct 中，则可以使用 Placement new 重新创建整个内容，从而重新绑定引用。正如 @HolyBlackCat 指出的，不要忘记使用 std::launder 来访问 re -创建的对象或使用从放置新返回的指针。考虑我的示例：

#include <iostream>

struct A {
    A(int& ref) : ref(ref) {}
    // A reference stored as a field
    int& ref;    
};

int main() {
  int a = 42;
  int b = 43;

  // When instance is created, the reference is bound to a
  A ref_container(a);
  std::cout << 
    "&ref_container.ref = " << &ref_container.ref << std::endl <<
    "&a = " << &a << std::endl << std::endl;

  // Re-create the instance, and bind the reference to b
  A* new_ref_container = new(&ref_container) A(b);
  std::cout <<
    // &ref_container and new_ref_container are the same pointers
    "&ref_container = " << &ref_container << std::endl <<
    "new_ref_container = " << new_ref_container << std::endl <<
    "&new_ref_container.ref = " << &new_ref_container->ref << std::endl <<
    "&b = " << &b << std::endl << std::endl;

  return 0;
}

demo

输出为：

&ref_container.ref = 0x7ffdcb5f8c44
&a = 0x7ffdcb5f8c44

&ref_container = 0x7ffdcb5f8c38
new_ref_container = 0x7ffdcb5f8c38
&new_ref_container.ref = 0x7ffdcb5f8c40
&b = 0x7ffdcb5f8c40

Answer 10

虽然这是一个坏主意，因为它违背了使用引用的目的，但可以直接更改引用

const_cast< int& >(ref)=b;