为什么我可以为引用指定一个新值，以及如何使引用引用引用其他内容？ 我有两个问题与C++中引用的使用有关。p>

在下面显示的代码中，它是如何工作的，并且不会在第

q=“world”行给出错误

p
处的字符串应该是常量，难道不应该更改吗


 >p>我读过C++引用类型变量，因为它们不能被重新初始化或重新分配，因为它们是作为常数指针存储在内部的。所以编译器会给出一个错误

但实际上如何重新分配引用变量呢

int i;

int &j = i;

int k;

j = k; //This should be fine, but how we reassign to something else to make compiler flag an error?

我正试图抓住这个参考资料，可能遗漏了一些关键的相关内容，所以这些问题

因此，任何澄清这一点的指针都是有用的。
关于引用的一个重要细节，我认为您缺少的是，一旦引用绑定到一个对象，您就永远无法重新分配它。从那时起，无论何时使用引用，都无法将其与使用引用的对象区分开来。例如，在您的第一段代码中，当您编写

q = "World";

由于
q
是绑定到
p
的引用，因此这相当于编写

p = "World";

它只是改变
p
指向的位置，而不是它指向的字符串的内容。（这也解释了为什么它不会崩溃！）

至于第二个问题，一旦绑定到对象，就不能重新分配引用。如果您需要一个可以更改其referent的引用，那么应该改用指针

希望这有帮助
 a）如何将引用q重新初始化为其他对象

不可能

引用变量仍然是在创建时初始化的别名


b） 字符串文本p=“Hello”不是只读空间中的常量/吗。因此，如果我们这样做，

不，它没有。

char* &q = p;

这里
q
是对char
p
类型指针的引用。这里的字符串是常量，指针不是常量，它可以指向另一个字符串，引用是该指针的别名，而不是字符串文字，因此它是有效的


第二个问题是，我读过C++引用类型变量，因为它们不能被重新初始化/重新赋值，因为它们是作为常数指针存储在内部的。所以编译器会给出一个错误

不会重新分配引用。它将更改其别名所对应的变量的值

在这种情况下，它将
i
的值更改为
k



a） 它不能，您引用的行不会更改引用
q
，而是更改
p
b） 不，文本是常量，但
p
是指向文本的指针。
指针可以更改，但指向的对象不能更改。
q=“世界”
使指针
p
指向其他对象

你似乎认为这个代码

int i;
int &j = i;
int k;
j = k;

正在重新分配引用，但它不是。
它将
k
的值赋给
i
，
j
仍然指
i
。
我猜这是你的主要误解

将引用视为别名，我希望引用的世界会更容易理解

int p; // Declares p as an integer; Defines p & allocates space
int &q = p ; // Declares a Reference. Though they are symbolically 2 variables,
             // they essentially refer to same name and same memory location.

所以，p=5和q=5都是一样的

以你为例,

char *p = "Hello"; // Declares your pointer to "Hello". p has its own existence.
char* &q = p;  // This now creates a reference (alias) to p with name q.

总而言之，p&q是实体/对象（内存）的名称

所以，如果你给q赋值，它也反映在p中。因为它与p的赋值相同。
所以q=“World”的意思是p现在也指向“World”。i、 e.p&q都引用的内存位置-保存“World”第一个字符的地址

如果您理解引用作为别名的概念，我希望不必回答第二个问题。
需要注意的是自C++20以来，可以使用
placement new
更改类内引用变量持有的引用，如以下示例所示：

struct C{
int&i；//~C（）；
new（this）C（other）；//自C++20以来即使在类上也是有效的
//带参考字段
}
}
};
int main（）{
INTA=3，b=5；
c1{.i=a}；
c2{.i=b}；
c1.foo（c2）；//c1中的内部参考字段i
//指的是a，现在指的是b！
}

代码：
准确地说，我的QN过去是，现在也是代码将重新分配对其他事物的引用的地方。（这在技术上是不允许的）我在OP中提到j=k；很好，因为我知道它会改变“裁判”的值。
int i;
int &j = i;
int k;
j = k;

int p; // Declares p as an integer; Defines p & allocates space
int &q = p ; // Declares a Reference. Though they are symbolically 2 variables,
             // they essentially refer to same name and same memory location.

char *p = "Hello"; // Declares your pointer to "Hello". p has its own existence.
char* &q = p;  // This now creates a reference (alias) to p with name q.

struct C {
  int& i; // <= a reference field
  void foo(const C& other) {
    if ( this != &other ) {
      this->~C();
      new (this) C(other); // valid since C++20 even on a class 
                           // with a reference field
    }
  }
};

int main() {
    int a = 3, b = 5;
    C c1 {.i = a};
    C c2 {.i = b};
    c1.foo(c2); // the inner reference field i inside c1
                // was referring to a and now refers to b!
}