C++11介绍

int main()
{
	// 右值引用只能右值，不能引用左值。
	int&& r1 = 10;
	int a = 10;
	int&& r2 = a;// error C2440: “初始化”: 无法从“int”转换为“int &&”, message : 无法将左值绑定到右值引用
	int&& r3 = std::move(a);// 右值引用可以引用move以后的左值
	return 0;
}

4.3左值引用的场景

先来回顾下左值引用的场景，以之前模拟实现的string进行比较。

class String
{
public:
	typedef char* iterator;
 
	String(const String& s)// 拷贝构造
		:_str(nullptr)
		, _size(0)
		, _capacity(0)
	{
		cout << "String(const String& s) -- 深拷贝" << endl;
 
		String tmp(s._str);
		swap(tmp);
	}
 
	String& operator=(const String& s)// 赋值重载
	{
		cout << "String& operator=(String s) -- 深拷贝" << endl;
		string tmp(s);
		swap(tmp);
 
		return *this;
	}
	void swap(String& s)// s1.swap(s2)
	{
		::swap(_str, s._str);
		::swap(_size, s._size);
		::swap(_capacity, s._capacity);
	}
 
	~String()
	{
		delete[] _str;
		_str = nullptr;
	}
	String& operator+=(char ch)
	{
		push_back(ch);
		return *this;
	}
	...........
	...........
    //其余函数的实现
 
private:
	char* _str;
	size_t _size;
	size_t _capacity;
};

上面String类中的那些拷贝构造中的参数，赋值重载的返回值等，都用了&，这样可以减少拷贝带来的消耗。但也存在一些函数，是不能用左值引用的。

例如：

 
	String to_String(int value)
	{
		bool flag = true;
		if (value < 0)
		{
			flag = false;
			value = 0 - value;
		}
 
	   String str;
		while (value > 0)
		{
			int x = value % 10;
			value /= 10;
 
			str += ('0' + x);
		}
 
		if (flag == false)
		{
			str += '-';
		}
 
		std::reverse(str.begin(), str.end());
		return str;//str是一个临时对象
	}
 
String s=to_String(1234);//会用str拷贝一个临时对象，再用那个临时对象拷贝构造s，优化后只有一次，

4.4右值引用的场景

右值也可分为纯右值，将亡值。

例如：

10；//纯右值
x+y;
 
string("hello"),//将亡值，只该变量马上要被销毁
string s("hello);
move(s);

上面String的模拟实现中，拷贝构造函数可以增加一个移动构造函数。

	String(String&& s)
			:_str(nullptr)
			, _size(0)
			, _capacity(0)
	{
			cout << "String(String&& s) -- 资源转移" << endl;
			swap(s);
	}

上面所用的是用右值去接受，可以认为s是一个将亡值，马上会被销毁，没必要去做深拷贝，只需将二者的资源进行转移即可（交换指针）。

 上面的to_String函数中，返回的str是一个临时对象，出作用域后会被销毁，增加了移动构造函数后，（此处可认为编译器做了优化，会将str识别为右值，因为它马上要被销毁），则会去匹配最适合的拷贝构造函数，这时会去调用移动构造函数，这样便减小了开销，（仅仅交换了指针，没有再去开辟空间）。

移动赋值：

对于一个已经存在的对象时，用一个即将被销毁的对象去赋值给它，也没必要去深拷贝。

      String& operator=(String&& s)
		{
			cout << "String& operator=(String&& s) -- 资源转移" << endl;
			swap(s);
			return *this;
		}

在c++11后，许多的容器中的函数都增加了右值的版本，如果情况适合，调用右值的版本就可以减少开空间的开销。

可以看下一：

 也可以用代码测试一下：

常用的swap函数：

 五.完美转发

5.1模板中的&& 万能引用

先看一个简单的例子：

void show(int& x) { cout << "左值引用\n"; }
void show(int&& x) { cout << "右值引用\n"; }
void show(const int& x) { cout << "const左值引用\n"; }
void show(const int&& x) { cout << "const右值引用\n"; }
 
 
template <class T>
void Fun(T&& x)
{
    show(x);
}
 
int main()
{
    int a = 10;
    const int b = 100;
    Fun(a);//左值
    Fun(b);
 
    Fun(999);//右值
    Fun(move(a));
    return 0;
}

结果：

左值引用
const左值引用
左值引用
左值引用

解释：

模板中的 && 不代表右值引用，而是万能引用，其既能接收左值又能接收右值。模板的万能引用只是提供了能够接收同时接收左值引用和右值引用的能力，但是引用类型的唯一作用就是限制了接收的类型，后续使用中都退化成了左值。

例如：int&& rr1 = 10; 10是右值，rr1是开了一块空间把10存储起来，是可以取地址的，则rr1是左值）

5.2完美转发

对上面的代码进行更改后：

void Fun(T&& x)
{
    show(forward(x));//完美转发
   
}

结果：

左值引用
const左值引用
右值引用
右值引用

6.新的类功能

默认成员函数

template <class ...Args>
void ShowList1(Args... args)
{
	// 参数个数
	cout << sizeof...(args) << endl;//计算的是参数包中形参的个数
}
 
int main()
{
	ShowList1(1,2,3,'x', 1.1);
}
 
结果：5