为什么使用临时 object 访问时引用类型是左值？

Question

为什么将值分配给使用临时 object 访问的引用变量有效，但不适用于非引用类型？

class a
{
    public:
        int m;
        int &n;
        a():m(2),n(m)
        {
            cout<< "A's constructor"<<endl;
        }
};

int main()
{
    // a().m = 6; // this gives an error that a temporary object is being used 
                  // as an lvalue
    a().n = 20;   // But this line works

    return 0;
}

Answer 1

但是a().n真的是暂时的吗？ 考虑这段代码：

class a
{
    public:
        int m;
        int &n;
        a():m(2),n(m)
        {
            cout<< "A's constructor"<<endl;
        }

        a(int& _n):m(2),n(_n)
        {
            cout<< "A's constructor"<<endl;
        }
};

int main()
{
    a().n = 20;   // (1)

    int n = 0;
    a(n).n        // (2)

    return 0;
}

第(2)行清楚地表明.n不是临时的。 它一定不是，因为它是对局部n变量的引用。

但是，编译器无法知道n将引用什么。 甚至可以做n(rand_bool()? m: _n)并且它必须工作。

相反，编译使用类型系统来知道应该分配什么。

例如，文字9是int类型的 pr 值。 你不能分配给它：

9 = 8; // nope

在您的代码中， a()是纯右值或类型a 。 它的所有价值成员也都是。 这就是a().m不起作用的原因。 m是纯右值。

但是， a().n是一个左值，因为n是一个左值引用。 不管它指向哪个变量。

Answer 2

a().n = 20;

因为n是左值引用类型，所以有效。 编译器不知道n在实现中是对m的引用。 它假定n是一个有效的左值引用，因此接受该行。

理论上，当您分配给a().n时，您可以分配给一个独立于a()生命周期的变量。 编译器无法评估这一点，如果它不接受该行，它将妨碍程序员。 想象一下下面的用例：

// Global variable.
int gv;

class a
{
    public:
        int m;
        int &n;
        a():m(2), n(gv)  // n is a reference to the global variable.
        {
            cout<< "A's constructor"<<endl;
        }
};

int main()
{
    a().n = 20;   // Changes gv. It is a valid operation.
    return 0;
}