重新启用RVALUE参考变量是合法的吗？

Question

当在单个范围中使用时，为什么要进行编译：

float x = 3.14;
auto &&expr = 2*x + x*x; // expr binds to the result of an expression
expr = x;

“ nofollow noreferrer”就像参考重结合一样，这是L值参考的非法。除此之外， expr 应该“是”表达式的结果。这如何“改变”？

Answer 1

您无法重新启用顶级参考，就像无法更改顶级const一样。但是当它们在课堂中存在时，您可以从C ++ 20开始。
有了C ++ 20，您可以重新定位参考，但具有很大的陷阱。它们，rvalue和lvalue refs删除默认的分配运算符，因此您必须编写自定义成员功能以使这样的类通常可用。

重新固定的LVALUE参考只需将其与不同的lvalue结合。 RVALUE REFS绑定到没有名称的TMP，因此具有影响其引用的TMP对象寿命的特殊特征。当原始Rvalue Refs的范围结束时，他们的寿命结束了。虽然，如果他们在班级中，它们可以反弹到其他rvalue，该班级对象的范围并不重要。而是终止其生命周期的是初始类对象的范围。

您无法重新启用顶级参考，但是，从C ++ 20开始，您可以重新启动使用 std :: struct_at 。

示例LVALUE参考：

#include <memory>
struct A { int& i; };
inline int f2(int i) {return 2 * i;}
int main() {
    float x = 3.14f;
    float&& expr = x * x + x * x; // expr binds to the result of an expression
    expr = x; // this isn't a rebind, just an assignment to an rvalue reference

    float& y = x;
    // no way to rebind y. It's an lvalue reference
    // and it cannot be changed to refer to another lvalue.

    // However, lvalue references that are inside a class can
    // be changed since an object of the class can be identified
    int i1{ 1 };
    int i2{ 2 };

    // lvalue reference in a class
    A a0{ i1 };
    A a1{ i2 };
    std::construct_at(&a0, a1); // a now contains a ref to i2;

这是一个计划，该程序演示了重新构建RVALUE REF的方式并不会延长裁判的寿命，即使其具有更长寿命的对象。

#include <memory>
#include <iostream>
struct B {
    inline static int seq{};
    int i;
    B() :i(seq++) {}
    ~B() {std::cout << "dtor " << i << "\n";}
};

B f(){return B();}

struct A {
    B&& rref;
};

int main() {
    {
        A a0{ f() };
        std::cout << "a0.rref.i=" << a0.rref.i << "\n";
        {
            A a1{ f() };
            std::construct_at(&a0, std::move(a1)); // a0.rref's tmp now disconnected replaced by a1.rref
            std::cout << "a0.rref.i=" << a0.rref.i << "\n";
            std::cout << "a1.rref.i=" << a1.rref.i << "\n";
        } // the tmp object referred to by both a0.rref and a1.rref, destroyed here when a1 goes out of scope
    } // the original tmp, which a0.rref n longer aliases, is destroyed here when a0 coes out of scope
}

/* Outputs *
a0.rref.i=0
a0.rref.i=1
a1.rref.i=1
dtor 1
dtor 0
***********/

感谢@HolyBlackCat的直截了当，这确实可以反弹。他们甚至可以参考相同的TMP对象。但是观看一生。

另一方面，与LVALUE裁判不同，我想不出一个用于重新介绍课程的用例。而且很少在班上的LVALUE参考。