这篇关于右值引用的Visual c++博客文章:

．.． c++不希望你意外地 修改临时对象，但是要直接修改 在上调用非const成员函数 可修改的右值是显式的，所以 这是允许的……

Basically, you shouldn't try to modify temporaries for the very reason that they are temporary objects and will die any moment now. The reason you are allowed to call non-const methods is that, well, you are welcome to do some "stupid" things as long as you know what you are doing and you are explicit about it (like, using reinterpret_cast). But if you bind a temporary to a non-const reference, you can keep passing it around "forever" just to have your manipulation of the object disappear, because somewhere along the way you completely forgot this was a temporary.

如果我是你，我会重新考虑我的功能设计。为什么g()接受引用，它修改参数了吗?如果不是，使它const引用，如果是，为什么你试图传递临时给它，你不在乎它是一个临时你正在修改?为什么getx()返回临时的?如果你和我们分享你的真实情况以及你想要实现的目标，你可能会得到一些关于如何做到这一点的好建议。

违背语言和愚弄编译器很少能解决问题——通常它会制造问题。

---

Edit: Addressing questions in comment: 1) `X& x = getx().ref(); // OK when will x die?` - I don't know and I don't care, because this is exactly what I mean by "going against the language". The language says "temporaries die at the end of the statement, unless they are bound to const reference, in which case they die when the reference goes out of scope". Applying that rule, it seems x is already dead at the beginning of the next statement, since it's not bound to const reference (the compiler doesn't know what ref() returns). This is just a guess however.

我清楚地说明了目的:不允许修改临时对象，因为这没有意义(忽略c++ 0x右值引用)。“那么为什么允许我调用非const成员?”这个问题很好，但我没有比上面已经提到的更好的答案了。 好吧，如果我对x中的x是正确的& x = getx().ref();在声明的最后，问题是显而易见的。

Anyway, based on your question and comments I don't think even these extra answers will satisfy you. Here is a final attempt/summary: The C++ committee decided it doesn't make sense to modify temporaries, therefore, they disallowed binding to non-const references. May be some compiler implementation or historic issues were also involved, I don't know. Then, some specific case emerged, and it was decided that against all odds, they will still allow direct modification through calling non-const method. But that's an exception - you are generally not allowed to modify temporaries. Yes, C++ is often that weird.

这篇关于右值引用的Visual c++博客文章:

．.． c++不希望你意外地 修改临时对象，但是要直接修改 在上调用非const成员函数 可修改的右值是显式的，所以 这是允许的……

Basically, you shouldn't try to modify temporaries for the very reason that they are temporary objects and will die any moment now. The reason you are allowed to call non-const methods is that, well, you are welcome to do some "stupid" things as long as you know what you are doing and you are explicit about it (like, using reinterpret_cast). But if you bind a temporary to a non-const reference, you can keep passing it around "forever" just to have your manipulation of the object disappear, because somewhere along the way you completely forgot this was a temporary.

如果我是你，我会重新考虑我的功能设计。为什么g()接受引用，它修改参数了吗?如果不是，使它const引用，如果是，为什么你试图传递临时给它，你不在乎它是一个临时你正在修改?为什么getx()返回临时的?如果你和我们分享你的真实情况以及你想要实现的目标，你可能会得到一些关于如何做到这一点的好建议。

违背语言和愚弄编译器很少能解决问题——通常它会制造问题。

---

Edit: Addressing questions in comment: 1) `X& x = getx().ref(); // OK when will x die?` - I don't know and I don't care, because this is exactly what I mean by "going against the language". The language says "temporaries die at the end of the statement, unless they are bound to const reference, in which case they die when the reference goes out of scope". Applying that rule, it seems x is already dead at the beginning of the next statement, since it's not bound to const reference (the compiler doesn't know what ref() returns). This is just a guess however.

我清楚地说明了目的:不允许修改临时对象，因为这没有意义(忽略c++ 0x右值引用)。“那么为什么允许我调用非const成员?”这个问题很好，但我没有比上面已经提到的更好的答案了。 好吧，如果我对x中的x是正确的& x = getx().ref();在声明的最后，问题是显而易见的。

Anyway, based on your question and comments I don't think even these extra answers will satisfy you. Here is a final attempt/summary: The C++ committee decided it doesn't make sense to modify temporaries, therefore, they disallowed binding to non-const references. May be some compiler implementation or historic issues were also involved, I don't know. Then, some specific case emerged, and it was decided that against all odds, they will still allow direct modification through calling non-const method. But that's an exception - you are generally not allowed to modify temporaries. Yes, C++ is often that weird.

邪恶的变通方法涉及'mutable'关键字。实际上，邪恶是留给读者的练习。或者查看这里:http://www.ddj.com/cpp/184403758

主要的问题是

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()));

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

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

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

在代码中，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