主要的问题是

g(getx()); //error

是一个逻辑错误:g正在修改getx()的结果，但您没有任何机会检查修改后的对象。如果g不需要修改形参，那么它就不需要左值引用，它可以通过value或const引用获取形参。

const X& x = getx(); // OK

有效，因为有时需要重用表达式的结果，而且很明显您正在处理一个临时对象。

然而，这是不可能的

X& x = getx(); // error

有效而不使g(getx())有效，这是语言设计者首先试图避免的。

g(getx().ref()); //OK

是有效的，因为方法只知道this的const性，它们不知道它们是在左值上调用还是在右值上调用。

就像在c++中一样，你有一个解决这个规则的方法，但是你必须显式地告诉编译器你知道你在做什么:

g(const_cast<x&>(getX()));

主要的问题是

g(getx()); //error

是一个逻辑错误:g正在修改getx()的结果，但您没有任何机会检查修改后的对象。如果g不需要修改形参，那么它就不需要左值引用，它可以通过value或const引用获取形参。

const X& x = getx(); // OK

有效，因为有时需要重用表达式的结果，而且很明显您正在处理一个临时对象。

然而，这是不可能的

X& x = getx(); // error

有效而不使g(getx())有效，这是语言设计者首先试图避免的。

g(getx().ref()); //OK

是有效的，因为方法只知道this的const性，它们不知道它们是在左值上调用还是在右值上调用。

就像在c++中一样，你有一个解决这个规则的方法，但是你必须显式地告诉编译器你知道你在做什么:

g(const_cast<x&>(getX()));

在代码中，getx()返回一个临时对象，即所谓的“右值”。你可以把右值复制到对象中(也就是。变量)或将它们绑定到const引用(这将延长它们的生命期，直到引用的生命期结束)。不能将右值绑定到非const引用。

这是一个经过深思熟虑的设计决策，以防止用户意外地修改一个将在表达式结尾死亡的对象:

g(getx()); // g() would modify an object without anyone being able to observe

如果你想这样做，你必须先创建一个对象的本地副本或将其绑定到一个const引用:

X x1 = getx();
const X& x2 = getx(); // extend lifetime of temporary to lifetime of const reference

g(x1); // fine
g(x2); // can't bind a const reference to a non-const reference

注意，下一个c++标准将包括右值引用。因此，您所知道的引用将被称为“左值引用”。你将被允许将右值绑定到右值引用，你可以在“右值”上重载函数:

void g(X&);   // #1, takes an ordinary (lvalue) reference
void g(X&&);  // #2, takes an rvalue reference

X x; 
g(x);      // calls #1
g(getx()); // calls #2
g(X());    // calls #2, too

右值引用背后的思想是，因为这些对象无论如何都会死亡，你可以利用这一知识并实现所谓的“移动语义”，一种特定的优化:

class X {
  X(X&& rhs)
    : pimpl( rhs.pimpl ) // steal rhs' data...
  {
    rhs.pimpl = NULL; // ...and leave it empty, but deconstructible
  }

  data* pimpl; // you would use a smart ptr, of course
};


X x(getx()); // x will steal the rvalue's data, leaving the temporary object empty

很明显，在上面的示例中，临时对象不是常量，因为调用 对于非常数函数是允许的。例如，ref()可以修改临时的 对象。”

在你的例子中，getX()不会返回一个const X，所以你可以像调用X().ref()一样调用ref()。你正在返回一个非const引用，因此可以调用非const方法，你不能做的是将ref赋值给一个非const引用。

加上SadSidos的评论，这使得你的三点不正确。

您所展示的是操作符链接是允许的。

 X& x = getx().ref(); // OK

表达式是'getx().ref();'，在赋值给'x'之前执行完成。

注意，getx()并不返回引用，而是返回一个进入本地上下文中的完整形式的对象。对象是临时的，但它不是const，因此允许您调用其他方法来计算值或发生其他副作用。

// It would allow things like this.
getPipeline().procInstr(1).procInstr(2).procInstr(3);

// or more commonly
std::cout << getManiplator() << 5;

请看这个答案的最后一个更好的例子

您不能将临时对象绑定到引用，因为这样做将生成对对象的引用，该对象将在表达式的末尾被销毁，从而留给您一个悬空引用(这是不整洁的，标准不喜欢不整洁)。

由ref()返回的值是一个有效的引用，但该方法并不关注它所返回的对象的生命周期(因为它不能在其上下文中拥有该信息)。你所做的基本上相当于:

x& = const_cast<x&>(getX());

对临时对象的const引用可以这样做的原因是，标准将临时对象的生命周期延长到引用的生命周期，因此临时对象的生命周期延长到语句结束之后。

那么剩下的唯一问题是，为什么标准不允许引用临时对象来将对象的生命延长到语句结束之后呢?

我相信这是因为这样做会使编译器很难得到正确的临时对象。这样做是为了对临时对象的const引用，因为它的用途有限，因此迫使你复制对象来做任何有用的事情，但确实提供了一些有限的功能。

想想这种情况:

int getI() { return 5;}
int x& = getI();

x++; // Note x is an alias to a variable. What variable are you updating.

延长这个临时对象的生命周期会让人非常困惑。 同时:

int const& y = getI();

将为您提供易于使用和理解的代码。

如果你想修改值，你应该将值返回给一个变量。如果您试图避免从函数中复制对象的代价(因为看起来对象是复制构造回来的(技术上它是))。那就不用麻烦了编译器很擅长"返回值优化"

为什么要在c++常见问题中讨论(粗体部分):

在c++中，非const引用可以绑定到左值，const引用可以绑定到左值或右值，但是没有任何东西可以绑定到非const右值。这是为了防止人们更改临时对象的值，因为临时对象的新值在使用之前就被销毁了。例如:

void incr(int& a) { ++a; }
int i = 0;
incr(i);    // i becomes 1
incr(0);    // error: 0 is not an lvalue

如果允许这个incr(0)，要么是一些没人见过的临时值被增加，要么更糟——0的值将变成1。后者听起来很愚蠢，但实际上在早期的Fortran编译器中有一个类似的错误，即留出一个内存位置来保存值0。