目录

一，左值与右值

二，右值引用

三，移动语义

四，完美转发

---

一，左值与右值

        左值与右值是C语言中的概率，但并没有严格的区分方式；表达式的”值分类“属性为左值和右值，左值是指存储在内存中有明确存储地址（可寻址）的数据，反之即为右值，是指那些可提供数据值的数据；左右值根本的区别在于是否可取地址以获取对应内存地址；

三个隐式自动转换

• 左值转换为右值，如i+3；
• 数组名为常量左值，在表达式中会转换为首元素地址；
• 函数名为常量左值，在表达式中转换为函数地址；

        通俗来说，可以放在=左边的、或能取地址的称为左值，只能放在=右边的、或不能取地址的称为右值，但不完全正确；可看出，左值一定可以作为右值，右值一定不能为左值；

左值 loactor value

• 普通类型的变量，可取地址，都认为是左值；
• const修饰的常变量，不可修改的只读类型，但可取地址，C++11认为是左值；
• 如表达式运行结果或单个变量是引用，则认为是左值；

int& fun(int& a) { return a; }
int a = 1;
const int b = 1;
int& c = a;
fun(a) = 10;

右值 read value

• C语言中的纯右值Pure Right Value（临时变量、字面值），如a+b、100；
  • 如表达式运行结果是临时变量或对临时象，则认为是右值；
• 将亡值Expiring Value，如表达式的中间结果，函数按照值的方式返回的返回值；

int fun(int& a) { return a; }
fun(a) = 10; //报错，fun(a)返回值是右值

二，右值引用

        C++98提出了引用的概念，引用即别名，引用变量与其引用的实体公共同一块空间，且引用的底层是通过指针来实现的，使用引用可提高程序的可读性；

void swap(int& left, int& right)
{
	int tmp = left;
	left = right;
	right = tmp;
}

        为了提高程序的运行效率，C++11引入了右值引用（&&），右值引用也是别名，但其只能对右值引用；

• 右值引用也必须立即进行初始化操作；
• 且只能使用右值进行初始化；
• 还可对右值进行修改；

int&& a = 1; //对右值进行引用
a = 10; //还可对右值引用进行修改
const int&& b = 1; //常量右值引用，无实际用处

引用与右值引用比较

• C++98中，普通引用只能引用左值不能引用右值，const引用即可引用左值也可引用右值；
• C++11中，右值引用只能引用右值，一般情况下不能直接引用左值；

//普通类型只能引用左值，不能引用右值
int a = 10;
int& ra = a;
//int& rb = 10; 编译失败，10是右值

const int& rb = 10;
const int& rc = a;

//右值引用只能引用右值，一般不能引用左值
int&& rd = 10;
//int&& re = a; 编译失败，a是左值

以值的形式返回对象的缺陷

        如一个类中涉及到资源管理，需显示提供拷贝构造、赋值运算符重载以及析构函数，否则拷贝对象或对象之间赋值就会出错(浅拷贝)；

class String
{
public:
	String(const char* str = "")
	{
		if (nullptr == str)
			str = "";
		_str = new char[strlen(str) + 1];
		strcpy(_str, str);
	}

	String(const String& s)
		:_str(new char[strlen(s._str) + 1])
	{
		strcpy(_str, s._str);
	}

	String& operator=(const String& s)
	{
		if (this != &s)
		{
			char* tmp = new char[strlen(s._str) + 1];
			strcpy(tmp, s._str);
			delete[] _str;
			_str = tmp;
		}
		return *this;
	}

	String operator+(const String& s)
	{
		char* tmp = new char[strlen(_str) + strlen(s._str) + 1];
		strcpy(tmp, _str);
		strcpy(tmp + strlen(_str), s._str);
		String strRet(tmp);
		return strRet;
	}

	~String() { delete[] _str; }
private:
	char* _str;
};

int main()
{
	String s1("hello");
	String s2("world");
	String s3(s1 + s2);
	return 0;
}

        上述代码s1+s2调用operator+中，返回strRet值时，需创建一个临时对象，然后销毁strRet，然后使用临时对象来构造s3，最后在销毁此临时对象；在这个过程中，strRet、临时对象，S3，都有自己独立的空间，相当于创建了三个内容完全相同的对象，浪费空间，程序效率低下，且临时对象作用不大；

三，移动语义

         C++11新增的特性，以提高对象传递和拷贝时的效率；即通过将资源所有权从一个对象转移到另一个对象，来避免不必要的内存分配和数据复制；具体表现为，通过“右值引用”将移动构造或移动赋值运算符设置为优先于常规的拷贝构造或拷贝赋值运算符；

• 即将一个对象中资源移动到另一个对象中的方式;
• C++11中如需实现移动语义，必须使用右值引用；

class A
{
public:
	A(int a) :_a(a) { cout << "A(int a)._a=" << _a << endl; } //构造,注意A(int&& a)
	A(A& a) :_a(a._a) { cout << "A(A& a)._a=" << _a << endl; } //拷贝构造
	A& operator=(const A& a) { _a = a._a; return *this; } //赋值重载

	A(A&& a)noexcept :_a(a._a) { cout << "A(A&& a)._a=" << _a << endl; } //移动构造
	A& operator=(A&& a)noexcept { _a = a._a; return *this; } //移动赋值重载
private:
	int _a;
};

int main()
{
	A a1(1), a2(2); //调用 A(int a)
	A a3(a1); //调用 A(A & a)
	a3 = a2; //调用 A& operator=(const A& a)

	A a4(move(a1)); //调用 A(A&& a)
	a4 = move(a2); //调用 A& operator=(A&& a)
	return 0;
}

上述代码s1+s2调用operator+中，引入移动构造，将strRet中资源转移到临时对象中；

String(String&& s)
	:_str(s._str)
{
	s._str = nullptr;
}

        strRet在创建好临时对象后将结束，是将亡值(属右值)；在用strRet构造临时对象时，就会调用移动构造，将strRet中资源转移到临时对象中，而临时对象也属于右值，因此在用临时对象构造s3时，也会调用移动构造，将临时对象中资源转移到s3中，整个过程只需创建一块堆内存即可，节省空间也提供运行效率；

• 移动构造函数的参数，不要设置成const类型的右值引用，因为资源无法转移而导致移动语义失效；
• 在C++11中编译器会为类默认生成一个移动构造，为浅拷贝，因此当类中涉及到资源管理时需显示定义移动构造；

右值引用引用左值

        按照语法右值引用只能引用右值，但有些场景可能需要用右值去引用左值实现移动语义；当需要用右值引用引用左值时，可通过move函数将左值转化为右值；

std::move()

• 函数位于头文件<utility>中；
• 其唯一的功能就是将一个左值强制转化为右值引用，以实现移动语义；

template<class _Ty>
inline typename remove_reference<_ty>::type&& move(_Ty&& _Arg) _NOEXCEPT
{
    return ((typename remove_reference<_Ty>::type&&)_Arg);
}

注：

• 被转化的左值，其生命周期并没有随左值的转化而改变，即std::move转化的左值变量不会被销毁；
• STL中也有另一个move函数，将一个范围的元素搬移到另一个位置；

String s1("hello world");
String s2(move(s1));
String s3(s2);

        以上代码是move函数的经典误用，move将s1转化为右值后，在实现s2的拷贝时会使用移动构造，此时s1的资源就被转移到s2中了，s1就会成为无效字符串；

四，完美转发

        以下PerfectForword为转发的模板函数，Func为实际目标函数，但转发不算完美；完美转发是将参数按照传递给PerfectForword转发函数的实际类型转发给目标函数，而不产生额外开销，就像不存在转发者一样；

void Func(int x){cout << x << endl;}

template<typename T>
void PerfectForward(T t)
{
    //目标函数
    Func(t);
}

        所谓完美，即模板函数在向其他函数传递自身形参时，如相应实参是左值，就应被转发为左值；如相应实参是右值，就应该被转发为右值；这样做是为了保留对转发而来的参数的左右值属性进行不同处理(如参数为左值时拷贝语义，参数为右值移动语义)；

• 完美转发是指在函数模板中，完全依照模板的参数类型，将参数传递给函数模板中调用的另一个函数；此时的右值引用称为”万能引用“；

引用折叠规则

• 当实参为左值（或左值引用）时，T&&转变为type&（或type& && = type&）；
• 当实参为右值（或右值引用）时，T&&转变为type&&（type&& && = type&&）；

函数模板std::forward

• 根据其参数类型，返回所需的左值引用或右值引用，并将左值引用或右值引用转发到其他函数；

lvalue (1)	
    template <class T> T&& forward (typename remove_reference<T>::type& arg) noexcept;
rvalue (2)	
    template <class T> T&& forward (typename remove_reference<T>::type&& arg) noexcept;

//C++11通过forward函数来实现完美转发！
void Fun(int& x) { cout << "int& -> lvalue ref" << endl; }
void Fun(int&& x) { cout << "int&& -> rvalue ref" << endl; }
void Fun(const int& x) { cout << "const int& -> lvalue ref" << endl; }
void Fun(const int&& x) { cout << "const int&& -> rvalue ref" << endl; }

template<typename T>
void PerfectForward(T&& t) //万能引用，即可传递左值也可传递右值
{
	Fun(std::forward<T>(t));
}

int main()
{
	PerfectForward(10); //10是右值，int&& -> rvalue ref

	int a;
	PerfectForward(a); //a是左值，int& -> lvalue ref
	PerfectForward(std::move(a)); //将a转化为右值 int&& -> rvalue ref

	const int b = 8;
	PerfectForward(b); //b是const左值 const int& -> lvalue ref
	PerfectForward(std::move(b)); //将b转化为const右值 const int&& -> rvalue ref
	return 0;
}

右值引用作用

        C++98中引用作用，因为引用是别名，需要用指针操作的地方，可以使用引用来替代，可提高代码的可读性及安全性；

C++11中右值引用主要有以下作用

• 实现移动语义(移动构造或移动赋值)；
• 给中间临时变量取别名；
• 实现完美转发；