1.统一的列表初始化
C++11扩大了用大括号括起的列表(初始化列表)的使用范围，使其可用于所有的内置类型和用户自
定义的类型，使用初始化列表时，可添加等号(=)，也可不添加。
struct Point
{int _x;int _y;
};
int main()
{int x1 = 1;int x2{ 2 };int array1[]{ 1, 2, 3, 4, 5 };int array2[5]{ 0 };Point p{ 1, 2 };// C++11中列表初始化也可以适用于new表达式中int* pa = new int[4]{ 0 };return 0;
}这里需要区分的另一个概念是初始化列表，两者是完全不同的概念。
2.右值引用和移动语义
2.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;
}左值与右值最大的区别是左值可以被取地址。
2.2 两者之间的比较
左值引用总结：
1. 左值引用只能引用左值，不能引用右值。
2. 但是const左值引用既可引用左值，也可引用右值。
int main()
{// 左值引用只能引用左值，不能引用右值。int a = 10;int& ra1 = a; // ra为a的别名//int& ra2 = 10; // 编译失败，因为10是右值// const左值引用既可引用左值，也可引用右值。const int& ra3 = 10;const int& ra4 = a;return 0;
} 右值引用总结：
1. 右值引用只能右值，不能引用左值。
2. 但是右值引用可以move以后的左值。
int main()
{// 右值引用只能右值，不能引用左值。int&& r1 = 10;// error C2440: “初始化”: 无法从“int”转换为“int &&”// message : 无法将左值绑定到右值引用int a = 10;int&& r2 = a;// 右值引用可以引用move以后的左值int&& r3 = std::move(a);return 0;
}2.3 左值引用的使用场景及短板
左值引用的使用场景：
做参数和做返回值都可以提高效率。
void func1(bit::string s)
{}
void func2(const bit::string& s)
{}
int main()
{L：：string s1("hello world");// func1和func2的调用我们可以看到左值引用做参数减少了拷贝，提高效率的使用场景和价值func1(s1);func2(s1);// string operator+=(char ch) 传值返回存在深拷贝// string& operator+=(char ch) 传左值引用没有拷贝提高了效率s1 += '!';return 0;
} 左值引用的短板：
但是当函数返回对象是一个局部变量，出了函数作用域就不存在了，就不能使用左值引用返回，
只能传值返回。传值返回会导致至少1次拷贝构造(如果是一些旧一点的编译器可能是两次拷贝构造)。
右值引用和移动语义解决上述问题：
移动构造本质是将参数右值的资源窃取过来，占为已有，那么就不 用做深拷贝了，所以它叫做移动构造，就是窃取别人的资源来构造自己。
// 移动构造
string(string&& s):_str(nullptr),_size(0),_capacity(0)
{cout << "string(string&& s) -- 移动语义" << endl;swap(s);
} 调用了移动构造，移动构造中没有新开空间，拷贝数据，所以效率提高了。
不仅仅有移动构造，还有移动赋值：
// 移动赋值
string& operator=(string&& s)
{
cout << "string& operator=(string&& s) -- 移动语义" << endl;
swap(s);
return *this;
}2.4 右值引用引用左值
当需要用右值引用引用一个左值时，可以通过move函数将左值转化为右值。C++11中，std::move()函数位于 头文件中，该函数名字具有迷惑性，它并不搬移任何东西，唯一的功能就是将一个左值强制转化为右值引用，然后实现移动语义。
2.5 完美转发
模板中的&& 万能引用
// 模板中的&&不代表右值引用，而是万能引用，其既能接收左值又能接收右值。
// 模板的万能引用只是提供了能够接收同时接收左值引用和右值引用的能力，
// 但是引用类型的唯一作用就是限制了接收的类型，后续使用中都退化成了左值，
// 我们希望能够在传递过程中保持它的左值或者右值的属性, 就需要用我们下面学习的完美转发
template<typename T>
void PerfectForward(T&& t)
{Fun(t);
}如果传进来的是左值，编译器会利用模板特性自动折叠成左值引用，如果传进来的是右值就不作任何改变。
3.新的类功能
C++11 新增了两个：移动构造函数和移动赋值运算符重载。
针对移动构造函数和移动赋值运算符重载有一些需要注意的点如下：
- 如果你没有自己实现移动构造函数，且没有实现析构函数 、拷贝构造、拷贝赋值重载中的任意一个。那么编译器会自动生成一个默认移动构造。默认生成的移动构造函数，对于内置类型成员会执行逐成员按字节拷贝，自定义类型成员，则需要看这个成员是否实现移动构造，如果实现了就调用移动构造，没有实现就调用拷贝构造。
- 如果你提供了移动构造或者移动赋值，编译器不会自动提供拷贝构造和拷贝赋值。
- 如果你没有自己实现移动赋值重载函数，且没有实现析构函数 、拷贝构造、拷贝赋值重载中的任意一个，那么编译器会自动生成一个默认移动赋值。默认生成的移动构造函数，对于内置类型成员会执行逐成员按字节拷贝，自定义类型成员，则需要看这个成员是否实现移动赋值，如果实现了就调用移动赋值，没有实现就调用拷贝赋值。(默认移动赋值跟上面移动构造
完全类似）。
强制生成默认函数的关键字default:
C++11可以让你更好的控制要使用的默认函数。假设你要使用某个默认的函数，但是因为一些原
因这个函数没有默认生成。比如：我们提供了拷贝构造，就不会生成移动构造了，那么我们可以
使用default关键字显示指定移动构造生成。
class Person
{
public:Person(const char* name = "", int age = 0):_name(name), _age(age){}Person(const Person& p):_name(p._name),_age(p._age){}
Person(Person&& p) = default; 禁止生成默认函数的关键字delete:
如果能想要限制某些默认函数的生成，在C++98中，是该函数设置成private，并且只声明补丁
已，这样只要其他人想要调用就会报错。在C++11中更简单，只需在该函数声明加上=delete即
可，该语法指示编译器不生成对应函数的默认版本，称=delete修饰的函数为删除函数。
class Person
{
public:Person(const char* name = "", int age = 0):_name(name), _age(age){}Person(const Person& p) = delete;继承和多态中的final与override关键字
- 在C++11中为了帮助程序员写继承结构复杂的类型，引入了虚函数描述符override，如果派生类在虚函数声明时使用了override描述符，那么该函数必须重写基类中的同名函数，否则代码无法通过编译。
- 当不希望某个类被继承，或不希望某个虚函数被重写，可以在类名和虚函数后添加final关键字，添加final关键字后被继承或重写，编译器会报错。
4.可变参数模板
下面就是一个基本可变参数的函数模板
// Args是一个模板参数包，args是一个函数形参参数包
// 声明一个参数包Args...args，这个参数包中可以包含0到任意个模板参数。
template <class ...Args>
void ShowList(Args... args)
{} 上面的参数args前面有省略号，所以它就是一个可变模版参数，我们把带省略号的参数称为“参数
包”，它里面包含了0到N（N>=0）个模版参数。我们无法直接获取参数包args中的每个参数的，
只能通过展开参数包的方式来获取参数包中的每个参数。
// 递归终止函数
template <class T>
void ShowList(const T& t)
{cout << t << endl;
}
// 展开函数
template <class T, class ...Args>
void ShowList(T value, Args... args)
{cout << value <<" ";ShowList(args...);
}
int main()
{ShowList(1);ShowList(1, 'A');ShowList(1, 'A', std::string("sort"));return 0;
}逗号表达式展开参数包
由于是逗号表达式，在创建数组的过程中会先执行逗号表达式前面的部分printarg(args)
打印出参数，也就是说在构造int数组的过程中就将参数包展开了，这个数组的目的纯粹是为了在
数组构造的过程展开参数包
template <class T>
void PrintArg(T t)
{cout << t << " ";
}
//展开函数
template <class ...Args>
void ShowList(Args... args)
{int arr[] = { (PrintArg(args), 0)... };cout << endl;
}
int main()
{ShowList(1);ShowList(1, 'A');ShowList(1, 'A', std::string("sort"));return 0;
}5.lambda表达式
5.1 语法
lambda表达式书写格式：[capture-list] (parameters) mutable -> return-type { statement }
（1）. lambda表达式各部分说明：
- [capture-list] : 捕捉列表，该列表总是出现在lambda函数的开始位置，编译器根据[]来判断接下来的代码是否为lambda函数，捕捉列表能够捕捉上下文中的变量供lambda函数使用。
- (parameters)：参数列表。与普通函数的参数列表一致，如果不需要参数传递，则可以连同()一起省略。
- mutable：默认情况下，lambda函数总是一个const函数，mutable可以取消其常量性。使用该修饰符时，参数列表不可省略(即使参数为空)。
- ->returntype：返回值类型。用追踪返回类型形式声明函数的返回值类型，没有返回值时此部分可省略。返回值类型明确情况下，也可省略，由编译器对返回类型进行推导。
- {statement}：函数体。在该函数体内，除了可以使用其参数外，还可以使用所有捕获到的变量。
注意：
在lambda函数定义中，参数列表和返回值类型都是可选部分，而捕捉列表和函数体可以为
空。因此C++11中最简单的lambda函数为：[]{}; 该lambda函数不能做任何事情。
int main()
{// 最简单的lambda表达式, 该lambda表达式没有任何意义[]{}; // 省略参数列表和返回值类型，返回值类型由编译器推导为intint a = 3, b = 4;[=]{return a + 3; }; // 省略了返回值类型，无返回值类型auto fun1 = [&](int c){b = a + c; }; fun1(10)cout<<a<<" "<<b<<endl;// 各部分都很完善的lambda函数auto fun2 = [=, &b](int c)->int{return b += a+ c; }; cout<<fun2(10)<<endl;// 复制捕捉xint x = 10;auto add_x = [x](int a) mutable { x *= 2; return a + x; }; cout << add_x(10) << endl; return 0;
} 通过上述例子可以看出，lambda表达式实际上可以理解为无名函数，该函数无法直接调
用，如果想要直接调用，可借助auto将其赋值给一个变量。
2. 捕获列表说明
捕捉列表描述了上下文中那些数据可以被lambda使用，以及使用的方式传值还是传引用。
- [var]：表示值传递方式捕捉变量var
- [=]：表示值传递方式捕获所有父作用域中的变量(包括this)
- [&var]：表示引用传递捕捉变量var
- [&]：表示引用传递捕捉所有父作用域中的变量(包括this)
- [this]：表示值传递方式捕捉当前的this指针
注意：
a. 父作用域指包含lambda函数的语句块。
b. 语法上捕捉列表可由多个捕捉项组成，并以逗号分割。
比如：[=, &a, &b]：以引用传递的方式捕捉变量a和b，值传递方式捕捉其他所有变量
[&，a, this]：值传递方式捕捉变量a和this，引用方式捕捉其他变量
c. 捕捉列表不允许变量重复传递，否则就会导致编译错误。
比如：[=, a]：=已经以值传递方式捕捉了所有变量，捕捉a重复
d. 在块作用域以外的lambda函数捕捉列表必须为空。
e. 在块作用域中的lambda函数仅能捕捉父作用域中局部变量，捕捉任何非此作用域或者
非局部变量都会导致编译报错。
f. lambda表达式之间不能相互赋值，即使看起来类型相同。
5.1 函数对象与lambda表达式
函数对象，又称为仿函数，即可以想函数一样使用的对象，就是在类中重载了operator()运算符的
类对象。
class Rate
{
public:Rate(double rate): _rate(rate){}double operator()(double money, int year){ return money * _rate * year;}
private:double _rate;
};
int main()
{
// 函数对象double rate = 0.49;Rate r1(rate);r1(10000, 2); 实际在底层编译器对于lambda表达式的处理方式，完全就是按照函数对象的方式处理的，即：如
果定义了一个lambda表达式，编译器会自动生成一个类，在该类中重载了operator()。
lambda表达式本质是一个仿函数
6.包装器
function包装器
function包装器 也叫作适配器。C++中的function本质是一个类模板，也是一个包装器。
std::function在头文件<functional>
// 类模板原型如下
template <class T> function; // undefined
template <class Ret, class... Args>
class function<Ret(Args...)>;
模板参数说明：
Ret: 被调用函数的返回类型
Args…：被调用函数的形参
// 使用方法如下：
#include <functional>
int f(int a, int b)
{return a + b;
}
struct Functor
{
public:int operator() (int a, int b){return a + b;}
};
class Plus
{
public:static int plusi(int a, int b){return a + b;}double plusd(double a, double b){return a + b;}
};
int main()
{// 函数名(函数指针)std::function<int(int, int)> func1 = f;cout << func1(1, 2) << endl;// 函数对象std::function<int(int, int)> func2 = Functor();cout << func2(1, 2) << endl;// lamber表达式std::function<int(int, int)> func3 = [](const int a, const int b)
{return a + b; };cout << func3(1, 2) << endl;// 类的成员函数std::function<int(int, int)> func4 = &Plus::plusi;cout << func4(1, 2) << endl;std::function<double(Plus, double, double)> func5 = &Plus::plusd;cout << func5(Plus(), 1.1, 2.2) << endl;return 0;
}有了包装器，解决了模板的效率低下，实例化多份的问题。
7.bind
std::bind函数定义在头文件中，是一个函数模板，它就像一个函数包装器(适配器)，接受一个可
调用对象（callable object），生成一个新的可调用对象来“适应”原对象的参数列表。使用std::bind函数还可以实现参数顺序调整等操作。
class Sub
{
public:int sub(int a, int b){return a - b;}
};
// 参数调换顺序
//_1为newCallable的第一个参数，_2为第二个参数，以此类推
std::function<int(int, int)> func4 = std::bind(&Sub::sub, s,
placeholders::_2, placeholders::_1);cout << func3(1, 2) << endl; cout << func4(1, 2) << endl;
