一、C++11简介

C++11是C++编程语言的一个版本，于2011年发布。C++11引入了很多新特性，比如：类型推导(auto关键字)、Lambda表达式、线程库、列表初始化，智能指针、右值引用、包装器等等。
C++11则带来了数量可观的变化，其中包含了约140个新特性，以及对C++03标准中约600个缺陷的修正，这使得C++11更像是从C++98/03中孕育出的一种新语言。相比较而言，C++11能更好地用于系统开发和库开发、语法更加泛华和简单化、更加稳定和安全，不仅功能更强大，而且能提升程序员的开发效率，公司实际项目开发中也用得比较多。
总的来说，C++11使得C++更加现代化、易用和强大。

二、右值引用

以前学习的引用就叫做左值引用。无论左值引用还是右值引用，都是给对象取别名。取别名就是减少拷贝
（1）先来理解左值和左值医用：
左值是一个表示数据的表达式(如变量名或解引用的指针)，我们可以获取它的地址+可以对它赋值，左值可以出现赋值符号的左边，右值不能出现在赋值符号左边。定义时const修饰符后的左值，不能给他赋值，但是可以取它的地址。左值引用就是给左值的引用，给左值取别名。

int main()
{
// 以下的p、b、c、*p都是左值
int* p = new int(0);
int b = 1;
const int c = 2;
// 以下几个是对上面左值的左值引用
int*& rp = p;
int& rb = b;
const int& rc = c;
int& pvalue = *p;
return 0;
}

理解右值和右值引用
右值也是一个表示数据的表达式，如：字面常量、表达式返回值，函数返回值(这个不能是左值引用返回)等等，右值可以出现在赋值符号的右边，但是不能出现出现在赋值符号的左边，右值不能取地址。右值引用就是对右值的引用，给右值取别名。

int main()
{
double x = 1.1, y = 2.2;
// 以下几个都是常见的右值
10;
x + y;
fmin(x, y);
// 以下几个都是对右值的右值引用
int&& rr1 = 10;
double&& rr2 = x + y;
double&& rr3 = fmin(x, y);
// 这里编译会报错：error C2106: “=”: 左操作数必须为左值
10 = 1;
x + y = 1;
fmin(x, y) = 1;
return 0;
}

看如下代码：

     int a=0;
     int * p=&a;
     int b=1;
     a+b;

小总结:
左值引用给左值取别名如：int &ret=a;
但左值不能给右值直接取引用，引用权限放大，加个const就可以
右值引用可以给右值取别名，如int &&ret1=(a+b)
右值引用不能去引用左值，int && ret2=是错的，但是可以对move后的左值取别名。

（2）右值引用的使用场景：
在传参的时候可以更好地进行参数匹配，比如调用同一个函数，可以把左值和右值区分出来。右值引用是和移动构造一块用的。
先看一段代码：

int main()
{
	nza::string s1("hello world");
	nza::string ret1 = s1;
	nza::string ret2 = (s1+'!');
	nza::string ret3 = move(s1);

	return 0;
}

如上，从拷贝的角度来看，s1是左值，s1+s2是右值，拷贝是有区别的，如果是内置类型区别不大，如果是自定义类型区别就大，它的右值又叫做将亡值，纯右值是内置类型。s1只能进行深拷贝，s1+s2都要亡了，没必要拷贝的，深拷贝是和你开一样大的空间，然后再把数据拷贝过来，再析构，但是将亡值做深拷贝的代价是有点大的，它的做法就是资源转移。
再看这下面代码：

namespace nza
{
	class string
	{
	public:
		typedef char* iterator;
		iterator begin()
		{
			return _str;
		}

		iterator end()
		{
			return _str + _size;
		}

		string(const char* str = "")
			:_size(strlen(str))
			, _capacity(_size)
		{
			//cout << "string(char* str)" << endl;

			_str = new char[_capacity + 1];
			strcpy(_str, str);
		}

		// s1.swap(s2)
		void swap(string& s)
		{
			::swap(_str, s._str);
			::swap(_size, s._size);
			::swap(_capacity, s._capacity);
		}

		// 拷贝构造
		string(const string& s)
			:_str(nullptr)
		{
			cout << "string(const string& s) -- 深拷贝" << endl;

			string tmp(s._str);
			swap(tmp);
		}

		// 移动构造
		string(string&& s)
			:_str(nullptr)
		{
			cout << "string(string&& s) -- 移动拷贝" << endl;
			swap(s);
		}

		// 赋值重载
		string& operator=(const string& s)
		{
			cout << "string& operator=(string s) -- 深拷贝" << endl;
			string tmp(s);
			swap(tmp);

			return *this;
		}

		~string()
		{
			delete[] _str;
			_str = nullptr;
		}

		char& operator[](size_t pos)
		{
			assert(pos < _size);
			return _str[pos];
		}

		void reserve(size_t n)
		{
			if (n > _capacity)
			{
				char* tmp = new char[n + 1];
				strcpy(tmp, _str);
				delete[] _str;
				_str = tmp;

				_capacity = n;
			}
		}

		void push_back(char ch)
		{
			if (_size >= _capacity)
			{
				size_t newcapacity = _capacity == 0 ? 4 : _capacity * 2;
				reserve(newcapacity);
			}

			_str[_size] = ch;
			++_size;
			_str[_size] = '\0';
		}

		//string operator+=(char ch)
		string& operator+=(char ch)
		{
			push_back(ch);
			return *this;
		}

		string operator+(char ch)
		{
			string tmp(*this);
			tmp += ch;
			return tmp;
		}

		const char* c_str() const
		{
			return _str;
		}
	private:
		char* _str;
		size_t _size;
		size_t _capacity; // 不包含最后做标识的\0
	};

	nza::string to_string(int value)
	{
		bool flag = true;
		if (value < 0)
		{
			flag = false;
			value = 0 - value;
		}

		nza::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;
	}
}

int main()
{
	nza::string s1("hello world");

	nza::string ret1 = s1;
	nza::string ret2 = (s1+'!');

	nza::string ret3 = move(s1);

	return 0;
}

刚才讲了区分左值和右值，先写一个和拷贝构造一样的函数，参数改为右值引用，如果是右值就没必要拷贝构造即深拷贝，我们直接改为swap(s)，直接交换地址，也就是直接指向你原来的空间，这叫做移动构造，ret1是深拷贝，ret2是移动构造，如图：

ret2直接转移资源，而ret1要去拷贝。这个拷贝的地方就是右值的使用场景之一。如果是左值要去深拷贝，如果是右值，都要走了，把资源带走不如给ret2，把原来的资源掠夺了，这样效率就变高了。如果你想把左值转走，就可以move一下，如ret3，相当于赋予了一种权限，可以转移资源，就可以匹配移动构造。

(3)具体使用场景：
左值引用了减少了拷贝，直接减少拷贝，使用场景左值引用传参和传引用返回，有些地方不能用传引用返回，如函数内的局部对象。
比杨辉三角返回的vector的vector即vector<vector>，拷贝代价太大了，有些场景不可避免就要传值返回，怎么可以解决？
C++11就是来解决这个问题的，里面的右值引用就是和左值区分的，区分之后，是右值就做资源转移，就不怕传值返回了，直接把资源转移给它，不需要析构需不要拷贝，这样极大提高了效率，因为有移动构造和编译器优化：
先看以前的C++98，拷贝优化两次变为1次

再看C++11，一次拷贝加一次移动构造优化为一次移动构造，优化之后先移动再析构

这个函数返回不能直接用引用不管是左值还是右值，因为它是一个局部对象，出了作用域之后就销毁了。
现在所有容器都增加了移动构造以及接口函数增加了右值引用版本。
总结：
左值引用减少拷贝，提高效率，右值引用也是减少拷贝，提高效率，但是左值引用是直接减少拷贝，右值引用是间接减少拷贝，识别出是左值还是右值，如果是右值不再深拷贝，直接移动拷贝即移动资源，提高效率。

（4）完美转发：
属性丢失，传两次就会导致属性丢失。
先看下面，写了一个模板，里面&&叫万能引用(引用折叠)，既可以引用左值，也可以引用右值。但是我们也有往下一层传的需求，如果是左值打印的是左值引用，右值打印的都是左值引用，这就是导致了属性丢失。

void Fun(int& x) { cout << "左值引用" << endl; }
void Fun(const int& x) { cout << "const 左值引用" << endl; }

void Fun(int&& x) { cout << "右值引用" << endl; }
void Fun(const int&& x) { cout << "const 右值引用" << endl; }


template<typename T>
void PerfectForward(T&& t)
{
	Fun(forward<T>(t));
}

int main()
{
	PerfectForward(10);           // 右值

	int a;
	PerfectForward(a);            // 左值
	PerfectForward(std::move(a)); // 右值

	const int b = 8;
	PerfectForward(b);		      // const 左值
	PerfectForward(std::move(b)); // const 右值

	int&& rr1 = 10;
	cout << &rr1 << endl;
	rr1++;*/

	string s1("hello world");
	string s2("hello world");
	string s3 = s1 + s2;*/

	return 0;
}

为什么会属性丢失？
再看，右值是不能取地址的，给右取别名后，会导致右值存储到特定位置，且可以取到改位置的地址，如上，10是不能取地址，但是rr1引用后，可以对rr1取地址也可以修改。这样做才符合语法，如sting ret=s1+s2，s1+s2是一个将亡值，不能直接去修改，编译器会找个地方把它存起来，存起来就可以修改但是属性就会变了。如下，想转移资源就得把swap(s)里面的s搞成左值，因为转移资源需要修改对象。

但是这样会造成困扰：
我们如果用之前我们手写的list，加入一个右值版本接口函数，进行插入自己手写的string类型，因为在insert里面在new新节点的时候会发生调用构造函数，因插入的是自定义类型，会调用自己的拷贝构造或移动构造，但是发现打印出来全都是深拷贝没有调用移动构造，这是因为在push_back里面的调用了insert，这里已经变化成了左值，但是真正实现转移的时候是在insert中调用构造函数，想转移资源但是时机未到，转早了，导致属性丢失，这时候C++11中增加了保持它原有的属性，叫做完美转发，语法为forward，就是解决转早的场景。如图：

解决之后就能成功打印,如图：

补充：还需要增加一个移动赋值：

// s1 = 将亡值
		string& operator=(string&& s)
		{
			cout << "string& operator=(string&& s) -- 移动赋值" << endl;
			swap(s);

			return *this;
		}

只有连续的构造或赋值才能被编译器优化：和二为一。

总结：
1、右值引用的特点是要借助移动拷贝去转移它的资源，右值按以前C++98的属性，临时对象具有常性不能修改，编译器会开一块空间把它存起来这样就可以修改，相当于它的属性就丢了，但是不一定在第一层就改即资源转移，有可能就如上面，可能会一层一层往下传需要复用，属性就丢了，这样就需要支持完美转发，继续保持它右值属性匹配。

2、左值引用和右值引用都是给对象取别名，减少拷贝，左值引用解决了大多数场景的问题，但是没解决局部独对象返回问题，和插入接口，对象拷贝问题。所以后面引入了右值引用。
浅拷贝的类，这里就是拷贝构造，因为对于浅拷贝的类，移动构造没意义。
深拷贝的类，是移动构造，移动构造对深拷贝的类有意义，可以转移右值的资源，没有拷贝，提高效率。

3、conat &延长的是临时对象或匿名对象的生命周期，传值返回的临时对象一般生成在上一层栈帧，例如上图to_string也就是main，to_string销毁不会影响main，如果小放在寄存器。如果to_string用const &返回str，在main函数中const &ref接收是不行的，返回时出了作用域就会被销毁，而且接收的时候用const&ref接收，main中的ref强行是str的别名，而str所在的空间已经销毁了，ref依旧是这块空间的别名，但这块空间没有使用权了，调完就回去了，再调用其他函数建立栈帧就会覆盖了，造成了非法引用。

4、如果没有自己实现移动构造函数，没有实现析构函数 、拷贝构造、拷贝赋值重载中的任意一个，编译器会自动生成一个默认移动构造。默认生成的移动构造函数，对于内置类型成员会执行逐成员按字节拷贝，自定义类型成员，则需要看这个成员是否实现移动构造，如果实现了就调用移动构造，没有实现就调用拷贝构造。
如果没有自己实现移动赋值重载函数，且没有实现析构函数 、拷贝构造、拷贝赋值重载中的任意一个，那么编译器会自动生成一个默认移动赋值。默认生成的移动构造函数，对于内置类型成员会执行逐成员按字节拷贝，自定义类型成员，则需要看这个成员是否实现移动赋值，如果实现了就调用移动赋值，没有实现就调用拷贝赋值。(默认移动赋值上面移动构造完全类似)如果你提供了移动构造或者移动赋值，编译器不会自动提供拷贝构造和拷贝赋值。

三、可变参数模板

可变参数模板能让我们创建可以接受可变参数的函数模板和类模板，C++98/03，类模版和函数模版中只能含固定数量的模版参数，可变模版参数出现就是解决固体化实现动态化。
下面是一个基本可变参数的函数模板

template <class ...Args>
void ShowList(Args... args)
{}

Args是一个模板参数包，args是一个函数形参参数包
声明一个参数包Args… args，这个参数包中可以包含0到任意个模板参数。
实际上是有这种需求的，有些地方不知道传几个参数，随便传，传几个接收几个。面的参数Args前面有省略号，所以它就是一个可变模版参数，我们把带省略号的参数称为“参数包”，它里面包含了0到N（N>=0）个模版参数。我们无法直接获取参数包args中的每个参数的，只能通过展开参数包的方式来获取参数包中的每个参数，这是使用可变模版参数的一个主要特点
如图：

如何解析出可变参数包：
不能直接用for循环打印，会报错要结合上下文推导，也就是用递归推导思维。
比如下面，1传过去val，后面没有参数，所以args是0个参数包，然后打印1,再去调ShowList，打印换行。同理如果2个参数，1传过去，后面还有一个参数A，args就是一个1参数包，打印1之后，再去调自己，推出一个char类型，打印A，没有参数包了，再调换行。

可变参数包在线程那一块用的比较多，因为可能要传0或多个参数。C语言用void*解决，而c++用模板参数包来解决。为我们把参数包解析出来。模板的可变参数包是为库里的而很多地方准备，不写库，一般很少用到。

还能这样写，给一个数组，参数包有几个就生成几个这样PrintArg表达式，那数组就开多大，这里参数包…在外面，一个一个传。

编译器编译推演生成了以下代码

void ShowList(char a1, char a2, std::string a3)
{
	int arr[] = { PrintArg(a1),PrintArg(a2),PrintArg(a3) };
	cout << endl;
}

四、 empacle_back(移动构造/赋值)

STL容器的插入接口都有一个emplace系列，一般都说它的效率比push_back高，这样说不是很准确。
如下图，还没多大区别：

当p和e都传一个子串时，就有区别了：
但是效率差别不大,但是因为e传的是可变参数包减少了一些拷贝，少构造一些对象，可以无脑使用它。p支持是可变参数包，里面用到一个万能引用。p支持一个一个左值引用和一个右值引用版本。
p是先构造，构造匿名对象是一个右值调用右值版本，再传参，进行移动构造；
而e这里是直接构造，传的是const char*，就没必要把参数包推出string，然后把这个东西认为构成string对象的参数，一路往下传，到结点的时候，直接拿这个参数包构造那个参数，就相当于传什么推什么，传const char推这个参数包为const char,然后调到这个参数包，把这个参数包一直往下传，传到定位new，定位new显示的调用string(ptr是结点data指针，data是string)构造函数，把参数const char*这个参数包传给它，一把构造到位。

五、简单特性

列表初始化：
C++98标准允许使用花括号{}对数组或者结构体元素进行统一的列表初始值设定，而C++11扩大了用大括号括起的列表(初始化列表)的使用范围，使其可用于所有的内置类型和用户自定义的类型，使用初始化列表时，可以省略赋值符号“=”。

struct N
{
int _x;
int _y;
};
int main()
{
int x1 = 0;
int x2{ 1 };
int a1[5]{ 1, 2, 3, 4, 5 };
int a2[10]{ 0 };
N n{ 1, 2 };
vector<int> l={1,2,3,4,5};
// C++11中列表初始化也可以适用于new表达式中
int* pp = new int[10]{ 0 };
return 0;
}

内置和自定义类型其实去调用了构造，而容器去匹配带有initializer_list的构造，做出了特殊识别，用花括号括起来的常量数组，C++把它识别为一个nitializer_list类型数组，比如在vector中增加了这样的构造，C++11对STL中的很多容器增加了它。

vector<initializer_list<T> li>
{
     typename::initializer_list<T>::iterator it=li.begin();
     while(it!=li.end())
     {
         push_back(*it);
         ++it;
     }
}

nullptr：
C++中NULL被定义成0，这可能回带来一些问题，因为0既能指针常量，又能表示整形常量。所以出于清晰和安全的角度考虑，C++11中新增了nullptr，用于表示空指针。
auto:
在C++98中auto是一个存储类型的说明符，表明变量是局部自动存储类型，但是局部域中定义局部的变量默认就是自动存储类型，所以auto就没什么价值了。C++11中废弃auto原来的用法，将其用于实现自动类型腿断。这样要求必须进行显示初始化，让编译器将定义对象的类型设置为初始化值的类型。

int main()
{
int n= 10;
auto p= &n;

map<string, string> m = { {"sort", "排序"}, {"insert", "插入"} };
//map<string, string>::iterator it = m.begin();
auto it = m.begin();
return 0;
}

decltype：
decltype是推导一个表达式的类型，用这个类型去实例化模板参数或定义对象。
比如下面：decltype去定义变量，x*y是什么类型，ret就是什么类型

template<class T1, class T2>
void F(T1 t1, T2 t2)
{
decltype(t1 * t2) ret;
cout << typeid(ret).name() << endl;
}
int main()
{
const int x = 3;
double y = 1.5;
decltype(x * y) ret; // ret的类型是double
decltype(&x) p;    // p的类型是int*
cout << typeid(ret).name() << endl;
cout << typeid(p).name() << endl;
F(1, 'a');
vector<decltype(x*y)> a; 
return 0;
}