为什么右值无法绑定到non-const引用

[chinesealbert]

以下是读书的原文：

====================================================================================================

T a(v);
这个语句显式用v作为参数调用T的某个最适合的可单参数调用的ctor来构造a
该语句形式被C++标准称为direct-initialization
这里强调两点，一个是显式，这说明这种方式构造a的话可以调用被explicit声明的ctor
第二点是最适合，这是由overload rules决定的，而不是那么想当然，示例代码如下
struct T
{
T(){}
T(int){}
operator int(){return 0;}
private:
T(T&){}
};
T foo() {return T();}
int main()
{
T a;

T b(a); // 编译出错，最适合的T(T&)不可访问，为private

T c(foo());// 编译成功，foo()返回的临时对象是rvalue，不能绑定到non-const引用
// 因此T(T&)不是由overload rules选定的最适合ctor
// 但是rvalue可以调用一次自定义隐式转换cast到int然后调用T(int)构造c
// 也就是说，overload rules选择了T(int)

return 0;
}
这段代码说明，即使类型相同，调用的也不一定是copy ctor
如果有人怀疑T(T&)不是copy ctor，认为T(const T&)才是，请参阅C++标准12.8
====================================================================================================


这里我不明白这一句话：“T c(foo());// 编译成功，foo()返回的临时对象是rvalue，不能绑定到non-const引用”
为什么？

[taodm]

因为“规定”

[晨星]

右值本来就不能绑定到non-const引用啊？这是基本语法规则。
楼主是问语言为啥这么规定吗？那也不难理解啊。非常量引用常常会修改被引用的对象，而允许一个右值老是被改来改去的，那不是很别扭么？

[HengStar]

举个简单的例子
看代码

void func( int& a )
{
   a = 10; // 给传进来的a赋值
}

func( 5 ); // 这样调用肯定是不通过编译的，因为5是常量（右值），不能给它赋值

[chinesealbert]

多谢上边几位的闪电速度般地答案！！


那我这样问吧，到底啥是右值？？

[taodm]

呃，那你就别讨论了，这是超级大坑了。要请 卫亭 大神才行的话题。

[HengStar]

只能在等号（赋值符号）右边使用的值叫右值（一般是常量或字面值）
5 = a; // 5肯定是右值，因为放在=号左边不能用
"sjdl" // 这个也是右值，字符串常量

[chinesealbert]

那就这样吧，简单的、按惯例的，什么是左值，什么是右值？
变量就是通常所说的左值？ 常量 或者 没有名字的量 通常就是右值？

如：
int t = 0;

t就是一个左值，对吧？
0就是一个右值，对吧？

const int a = 0;
a也应该是个右值，对吧？

[pengzhixi]

[Quote=引用 7 楼 gongxinheng 的回复:]
只能在等号（赋值符号）右边使用的值叫右值（一般是常量或字面值）
5 = a; // 5肯定是右值，因为放在=号左边不能用
"sjdl" // 这个也是右值，字符串常量
[/Quote]

只能在等号右边使用的值叫右值。这应该是以前的 说法了 。

[taodm]

抱歉，a是左值，不可修改的左值。
所以，真的不要去钻“左值、右值”的牛角尖了。

[晨星]

左右值的详细区分你自己查资料吧。
但如果不想研究的很细，基本上可以这么认为：能放在赋值号左边的都是左值，否则，八成是右值。

像你定义的那个foo()函数，你调用它所返回的那个临时的对象就是右值，因此，你写
T t = foo();
有可能成功，但写：
T t;
foo() = t;
肯定不行。

[chinesealbert]

我懂了，我懂了：

struct T
{
T(){}
T(int){}
operator int(){return 0;}
private:
T(T&){}
};
T foo() {return T();}
int main()
{
T a = foo(); //通过
const T &b = a; //通过！！
T &c = foo(); //不通过，理由如上，对否？？
}

[chinesealbert]

我懂了，我懂了：

struct T
{
T(){}
T(int){}
operator int(){return 0;}
private:
T(T&){}
};
T foo() {return T();}
int main()
{
T a = foo(); //通过
const T &b = a; //通过！！
const T &c = foo(); //不通过，理由如上，对否？？
}

[chinesealbert]

刚才12楼少写一个const，请直接看13楼

[晨星]

[Quote=引用 12 楼 chinesealbert 的回复:]
int main()
{
  T a = foo(); //通过
  const T &b = a; //通过！！
  T &c = foo(); //不通过，理由如上，对否？？
}
[/Quote]
第一个俺就不评论了，毕竟你的构造函数是私有的，而且参数还是非常量的引用。
后两个没错，就是这样，呵呵。

[taodm]

13楼的代码你真的编译过？

[晨星]

应该这么说：
const T& t = foo();
是可以的。
T& t = foo();
不可以。

[chinesealbert]

[Quote=引用 16 楼 taodm 的回复:]
13楼的代码你真的编译过？
[/Quote]

没有呀。。。。 我没钱买计算机，所以就只能来这里发问题了，难道你把我忘记了？

[taodm]

哦，那你继续。

[光宇广贞]

右移在语义上是这样的，基本上简单地说，就是“不具名，不对应内存块”，比如常数可以做为右值，临时对像也可以做为右值，右值具有“移动语义”，就是我把我的值移动给你，然后我自身可能就消失掉了，比如常数给变量赋值，和临时对像给实对像的赋值过程……

T& 这个，就是 non-const 本质上是“左值”语义的，左值与右值对应，就是“具名，且对应内存”，左值变量是可以访问的，因为它对应内存，因故可以将左值放到等号左边。

语义上明晰的话，那么为何临时对像不能给 non-const 就好解释了。左值可以做右值，右值不可以做左值。在 C++ 98/03 现行标准下，右值只可以传参给 const 形参，而绝对不可以给 non-const 形参，而在新标准 C++ 09 里面，对左值与右值做了更为严格和明晰地区别，楼主可以关注一下。

[光宇广贞]

对了，好像我忘了说为何 non-const 本质上是“左值语义”，这个，多说一句便是……你不是可以“指名道姓”地“引用”它并修改值么？所以是左值的。