非常量引用的初始值必须为左值

问题描述

先看一段报错的代码：

#include<iostream>
using namespace std;

int main()
{
	int i = 2;
	double &r = i;
	system("pause");
	return 0;
}

对上面的程序进行修改 :

#include<iostream>
using namespace std;

int main()
{
	int i = 2;
	int &r = i;
	system("pause");
	return 0;
}

或

#include<iostream>
using namespace std;

int main()
{
	int i = 2;
	const double &r = i;
	system("pause");
	return 0;
}

此时上面两个程序就都不再报错了。

原因分析

其实：

const double &r = i; 

由于类型不匹配，实际相当于：

const double inner_tmp = (double)i;  //这里就产生了一个临时变量
const double &r = inner_tmp;

临时的中间变量都是const，所以没有const的引用会失败。

左值与右值

C++ 11中引入的一个非常重要的概念就是右值引用。理解右值引用是学习“移动语义”（move semantics）的基础。而要理解右值引用，就必须先区分左值与右值。

对左值和右值的一个最常见的误解是：等号左边的就是左值，等号右边的就是右值。

左值和右值都是针对表达式而言的，左值是指表达式结束后依然存在的持久对象，右值是指表达式结束时就不再存在的临时对象。一个区分左值与右值的便捷方法是：看能不能对表达式取地址，如果能，则为左值，否则为右值。下面给出一些例子来进行说明。

int a =  10;
int b =  20;
int* pFlag = &a;
vector< int> vctTemp;
vctTemp.push_back( 1);
string str1 =  " hello  ";
string str2 =  " world ";
const  int &m =  1;

请问，a，b，a+b，a++，++a，pFlag，*pFlag，vctTemp[0]，100，string(“hello”)，str1，str1+str2，m分别是左值还是右值？

左值引用

非常量左值引用

非常量左值引用只能绑定到非常量左值，不能绑定到常量左值、非常量右值和常量右值。如果允许绑定到常量左值和常量右值，则非常量左值引用可以用于修改常量左值和常量右值，这明显违反了其常量的含义。如果允许绑定到非常量右值，则会导致非常危险的情况出现，因为非常量右值是一个临时对象，非常量左值引用可能会使用一个已经被销毁了的临时对象。

常量左值引用

常量左值引用可以绑定到所有类型的值，包括非常量左值、常量左值、非常量右值和常量右值。

右值引用

右值引用根据其修饰符的不同，也可以分为非常量右值引用和常量右值引用。

非常量右值引用

非常量右值引用只能绑定到非常量右值，不能绑定到非常量左值、常量左值和常量右值。如果允许绑定到非常量左值，则可能会错误地窃取一个持久对象的数据，而这是非常危险的；如果允许绑定到常量左值和常量右值，则非常量右值引用可以用于修改常量左值和常量右值，这明显违反了其常量的含义。

常量右值引用

常量右值引用可以绑定到非常量右值和常量右值，不能绑定到非常量左值和常量左值（理由同上）。

为什么要使用非常量右值引用

考虑下面的代码：

vector<int> GetAllScores()
{
	vector<int> vctTemp;
	vctTemp.push_back(90);
	return vctTemp;
}

当使用vector<int> vctScore = GetAllScores();进行初始化时，实际上调用了一次ctor和两次copy ctor。尽管有些编译器可以采用RVO（Return Value Optimization）来进行优化，但优化工作只在某些特定条件下才能进行。可以看到，上面很普通的一个函数调用，由于存在临时对象的拷贝，导致了额外的两次copy ctor和dtor的开销。

再看一段代码：

#include<iostream>
using namespace std;

class A
{
public:
	A() { cout << "Constructor" << endl; }
	A(const A&) { cout << "Copy Constructor" << endl; }
	~A() {}
};

A getA()
{
	A a;
	return a;
}

int main()
{
	A a = getA();// getA()是临时对象，是一个右值
	system("pause");
	return 0;
}

可以看到A的构造函数调用一次，拷贝构造函数调用了一次，构造函数和拷贝构造函数是消耗比较大的，这里是否可以避免拷贝构造？C++11做到了这一点。（注意，上面这个例子中，虽然getA()是一个右值，但是由于没有自定义move constructor，所以调用了默认的copy constructor。如果对象中有堆内存管理，必须定义move constructor。）

对上面的代码进行优化：

#include<iostream>
using namespace std;
class A
{
public:
	A() { cout << "Constructor" << endl; }
	A(const A&) { cout << "Copy Constructor" << endl; }
	A(const A&&) { cout << "Move Constructor" << endl; }
	~A() {}
};

A getA()
{
	A a;
	return a;
}

int main()
{
	A a = getA();// getA()是一个右值
	system("pause");
	return 0;
}

后续关于移动构造函数的优点以前整理过，见C++11——移动构造函数及std::move() 的使用