目录
1. 统一的列表初始化
①{}进行初始化
②std::initializer_list
1.类型
2.使用场景
2.声明
①auto
②decltype
③nullptr
3.范围for
4.右值引用与移动语义
①左值引用与右值引用
②左值引用与右值引用的比较
③左值引用与右值引用的使用场景与意义、移动语义
④右值引用引用左值及其一些更深入的使用场景分析
⑤完美转发
1.模板中的&&、万能引用
2.std::forward 完美转发在传参的过程中保留对象原生类型属性
3.完美转发实际中的使用场景
5.STL的变化
①新容器
②容器中的一些新接口
1.迭代器接口
2.所有容器均支持了{}列表初始化的构造函数
3.所有容器均新增了emplace系列
4.容器新增了移动构造与移动赋值
6.类的变化
①默认成员函数
②类成员变量初始化
③强制生成默认函数的关键字default
④禁止生成默认函数的关键字delete
⑤继承和多态中的final与override关键字
7.可变参数模板
①使用递归函数方式展开参数包
②使用逗号表达式展开参数包
③STL中的emplace接口
8.lambda表达式
①C++98中的一种情况
②lambda表达式
③lambda表达式语法
④函数对象与lambda表达式
9.包装器
①function包装器
②bind
1. 统一的列表初始化
①{}进行初始化
在C++98标准中，允许使用花括号{}对数组或者结构体元素进行统一的列表初始值设定。即
struct Point
{
int _x;
int _y;
};
int main()
{
int array1[] = { 1, 2, 3, 4, 5 };
int array2[5] = { 0 };
Point p = { 1, 2 };
return 0;
}而在C++11中，大括号括起的列表(初始化列表)的使用范围被扩大了，使其可用于所有的内置类型和用户自定义的类型，使用初始化列表时，可添加等号(=)，也可不添加。如
struct Point
{
Point(int x, int y)
:_x(x)
,_y(y)
{
cout << "Point(int x, int y)" << endl;
}
int _x;
int _y;
};
int main()
{
int x = 1;
int y = { 2 };
int z{ 3 };
int a1[] = { 1,2,3 };
int a2[] { 1,2,3 };
// 本质都是调用构造函数
Point p0(0, 0);
Point p1 = { 1,1 }; // 多参数构造函数隐式类型转换
Point p2{ 2,2 };
const Point& r = { 3,3 };
int* ptr1 = new int[3]{ 1,2,3 };
Point* ptr2 = new Point[2]{p0,p1};
Point* ptr3 = new Point[2]{ {0,0},{1,1} };
return 0;
}注：建议在日常定义中，不要去掉=，虽然不要求会用但是要能看懂
②std::initializer_list
1.类型
在这里我们可以使用typeid来查看一个变量的类型，即
int main()
{
// the type of il is an initializer_list
auto il = { 10, 20, 30 };
cout << typeid(il).name() << endl;
return 0;
}运行有
2.使用场景
std::initializer_list一般是作为构造函数的参数，C++11对STL中的不少容器就增加了std::initializer_list作为参数的构造函数，这样初始化容器对象就更方便了。
让我们查看几个STL的文档
也可以作为operator=的参数，这样就可以用大括号赋值
举几个例子
int main()
{
vector<int> v = { 1,2,3,4 };
list<int> lt = { 1,2 };
// 这里{"sort", "排序"}会先初始化构造一个pair对象
map<string, string> dict = { {"sort", "排序"}, {"insert", "插入"} };
// 使用大括号对容器赋值
v = { 10, 20, 30 };
return 0;
}2.声明
C++11提供了多种简化声明的方式，尤其是在使用模板时。
①auto
在C++98中auto是一个存储类型的说明符，表明变量是局部自动存储类型，但是局部域中定义局部的变量默认就是自动存储类型，所以auto就没什么价值了。C++11中废弃auto原来的用法，将其用于实现自动类型推断。这样要求必须进行显示初始化，让编译器将定义对象的类型设置为初始化值的类型。举个例子
int main()
{
int i = 10;
auto p = &i;
auto pf = strcpy;
cout << typeid(p).name() << endl;
cout << typeid(pf).name() << endl;
map<string, string> dict = { {"sort", "排序"}, {"insert", "插入"} };
//map<string, string>::iterator it = dict.begin();
auto it = dict.begin();
return 0;
}
②decltype
我们使用typeid只能查看数据类型而不能使用它来创建新的变量，此时我们就需要使用decltype，举例如下
class A
{
private:
decltype(malloc) pf2;
};
template<class Func>
class B
{
private:
Func _f;
};
int main()
{
auto pf = malloc;
auto pf1 = pf;
// decltype推出对象的类型，再定义变量，或者作为模板实参
// 单纯先定义一个变量出现
decltype(pf) pf2;
B<decltype(pf)> bb1;
const int x = 1;
double y = 2.2;
B<decltype(x * y)> bb2;
return 0;
}③nullptr
由于C++中NULL被定义成字面量0，这样就可能会带来一些问题，因为0既能指针常量，又能表示整形常量。所以出于清晰和安全的角度考虑，C++11中新增了nullptr，用于表示空指针。
在C++中NULL的定义如下
#ifndef NULL
#ifdef __cplusplus
#define NULL 0
#else
#define NULL ((void *)0)
#endif
#endif3.范围for
在C++98中如果要遍历一个数组，可以按照以下方式进行：
int main()
{
int array[] = { 1, 2, 3, 4, 5 };
for (int i = 0; i < sizeof(array) / sizeof(array[0]); ++i)
{
array[i] *= 2;
}
for (int* p = array; p < array + sizeof(array) / sizeof(array[0]); ++p)
{
cout << *p << endl;
}
return 0;
}对于一个有范围的集合而言，由程序员来说明循环的范围是多余的，有时候还会容易犯错误。因此C++11中引入了基于范围的for循环。for循环后的括号由冒号“ ：”分为两部分：第一部分是范围内用于迭代的变量，第二部分则表示被迭代的范围。示例如下
int main()
{
int array[] = { 1, 2, 3, 4, 5 };
for (auto& e : array)
{
e *= 2;
}
for (auto e : array)
{
cout << e << " ";
}
return 0;
}注：与普通循环类似，可以用continue来结束本次循环，也可以用break来跳出整个循环。
4.右值引用与移动语义
①左值引用与右值引用
在我们之前的学习中，我们已经知道了引用的语法，而C++11中新增了的右值引用语法特性，所以从现在开始我们之前学习的引用就叫做左值引用。无论左值引用还是右值引用，都是给对象取别名。既然如此，那么什么是左值什么是右值呢？首先是左值
左值是一个表示数据的表达式(如变量名或解引用的指针)，我们可以获取它的地址也可以对它赋值，左值可以出现在赋值符号的左边，右值不能出现在赋值符号左边。定义时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;
}不难看出，区别一个数据是左值还是右值只需要看能否被取地址，能就是左值，不能就是右值。
②左值引用与右值引用的比较
对于左值引用我们总结如下
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;
}注：move实际上在使用后会将move的资源转移到右值引用的对象，这之后自己会被置空。
③左值引用与右值引用的使用场景与意义、移动语义
在前面的总结中我们可以发现，左值引用既可以引用左值又可以引用右值，那么右值引用的存在有何意义呢？其实左值引用在一些场景之中具有一些短板，右值引用则可以弥补这些短板。
在这里我们使用之前模拟实现的string类作为参考，即String类的模拟实现，并对其做一些改造（调用相对的函数的打印一下），方便我们进行观察，我们已经知道，引用的价值是作为参数与返回值，在如下的一些场景中左值引用都能起到很好的作用
void func1(my_string::string s)
{}
void func2(const my_string::string& s)
{}
int main()
{
my_string::string s1("hello world");
// func1和func2的调用我们可以看到
// 左值引用做参数减少了拷贝，提高效率的使用场景和价值
func1(s1);
func2(s1);
// string operator+=(char ch) 传值返回存在深拷贝
// string& operator+=(char ch) 传左值引用没有使用深拷贝，从而提高了效率
s1 += '!';
return 0;
}运行有
但是当函数返回对象是一个局部变量时，出了函数作用域就不存在了，就不能使用左值引用返回，只能传值返回。举个例子
my_string::string func()
{
my_string::string str = "aaaaaaaaaa";
//...
return str;
}可以看到，这里只能使用传值返回，而传值返回会导致至少1次拷贝构造(如果是一些旧一点的编译器可能是两次拷贝构造)。
func的返回值是一个右值，用这个右值构造ret1，如果没有移动构造，调用就会匹配调用拷贝构造，因为const左值引用是可以引用右值的，这里就是一个深拷贝。为了解决上述的问题，我们可以在my_string::string中增加移动构造，移动构造本质是将参数右值的资源窃取过来，占位已有，那么就不用做深拷贝了，所以它叫做移动构造，就是窃取别人的资源来构造自己。
// 移动构造
string(string&& s)
:_str(nullptr)
,_size(0)
,_capacity(0)
{
cout << "string(string&& s) -- 移动构造" << endl;
swap(s);
}再运行上面func时，我们会发现，这里没有调用深拷贝的拷贝构造，而是调用了移动构造，移动构造中没有新开空间和拷贝数据，所以效率提高了。因为这里func的返回值是一个右值，用这个右值构造ret1，如果既有拷贝构造又有移动构造,调用就会自动匹配调用移动构造，因为编译器会选择最匹配的参数调用。那么这里就是一个移动语义
除了移动构造外还有移动赋值，我们向my_string::string中添加下列移动赋值函数
// 移动赋值
string& operator=(string&& s)
{
cout << "string& operator=(string&& s) -- 移动赋值" << endl;
swap(s);
return *this;
}此时再运行下列代码有
这里运行后，我们看到调用了移动赋值。因为如果是用一个已经存在的对象接收，编译器就没办法优化了。这里会先用str生成构造生成一个临时对象，然后在把这个临时对象做为func函数调用的返回值赋值给ret1，这里调用了移动赋值。具体来说，移动构造和移动赋值都是在返回临时对象时，编译器会自动将这个临时对象认定为将亡值，然后对其使用移动语义，通俗一点来说就是编译器认为“你反正都要没了，不如把你的所有资源给另一个人，然后自己什么都不带再去世”。
④右值引用引用左值及其一些更深入的使用场景分析
按照语法，右值引用只能引用右值，但右值引用一定不能引用左值吗？因为：有些场景下，可能真的需要用右值去引用左值实现移动语义。当需要用右值引用引用一个左值时，可以通过move函数将左值转化为右值。C++11中，std::move()函数位于头文件中，该函数名字具有迷惑性，它并不搬移任何东西，唯一的功能就是将一个左值强制转化为右值引用，然后实现移动语义。
对于下面这段代码
int main()
{
my_string::string s1("hello world");
// 这里s1是左值，调用的是拷贝构造
my_string::string s2(s1);
my_string::string s3(std::move(s1));
return 0;
}运行之后可以发现，经过move之后s1的资源被置空，因为其所有资源都被转移给了s3
此外，在C++11中容器的插入接口也都加入了右值引用版本，举几个例子
这里我们用list的插入接口来举例
int main()
{
list<my_string::string> v;
my_string::string s1("1111");
// 这里调用的是拷贝构造
v.push_back(s1);
// 下面调用都是移动构造
v.push_back("2222");
v.push_back(std::move(s1));
return 0;
}
即第一个push_back插入newnode时，string里面的数据需要深拷贝一份供newnode使用，而后面的push_back插入时，因为传入的string被编译器认定为将亡值，直接使用其移动构造一份数据供newnode使用，这样就减少了需要拷贝的次数。
综上所述，我们可以知道使用右值引用的场景大概有两种，第一种是自定义类型在某个函数中，含有深拷贝，且必须使用传值返回的情况，第二种则是在容器的插入接口中，如果待插入的对象为右值，可以利用移动构造将其资源转移到数据结构中。
⑤完美转发
1.模板中的&&、万能引用
我们先来看下面这段代码
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(t);
}
int main()
{
PerfectForward(10);
int a;
PerfectForward(a);
PerfectForward(std::move(a));
const int b = 8;
PerfectForward(b);
PerfectForward(std::move(b));
return 0;
}在运行之后可以发现
这与我们理想中想要的到的答案略有差异，其实模板中的&&不代表右值引用，而是万能引用，其既能接收左值又能接收右值。模板的万能引用只是提供了能够接收同时接收左值引用和右值引用的能力，但是引用类型的唯一作用就是限制了接收的类型，后续使用中都退化成了左值，我们希望能够在传递过程中保持它的左值或者右值的属性, 就需要用我们下面学习的完美转发
2.std::forward 完美转发在传参的过程中保留对象原生类型属性
我们只需要使用std::forward就可以保留对象的原生类型属性，即
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(std::forward<T>(t));
}
int main()
{
PerfectForward(10);
int a;
PerfectForward(a);
PerfectForward(std::move(a));
const int b = 8;
PerfectForward(b);
PerfectForward(std::move(b));
return 0;
}此时，我们再次运行有
这样就达到了我们想要的效果
3.完美转发实际中的使用场景
在这里举list为例
template<class T>
struct ListNode
{
ListNode* _next = nullptr;
ListNode* _prev = nullptr;
T _data;
};
template<class T>
class List
{
typedef ListNode<T> Node;
public:
List()
{
_head = new Node;
_head->_next = _head;
_head->_prev = _head;
}
void PushBack(T&& x)
{
//Insert(_head, x);
Insert(_head, std::forward<T>(x));
}
void PushFront(T&& x)
{
//Insert(_head->_next, x);
Insert(_head->_next, std::forward<T>(x));
}
void Insert(Node* pos, T&& x)
{
Node* prev = pos->_prev;
Node* newnode = new Node;
newnode->_data = std::forward<T>(x); // 关键位置
// prev newnode pos
prev->_next = newnode;
newnode->_prev = prev;
newnode->_next = pos;
pos->_prev = newnode;
}
void Insert(Node* pos, const T& x)
{
Node* prev = pos->_prev;
Node* newnode = new Node;
newnode->_data = x; // 关键位置
// prev newnode pos
prev->_next = newnode;
newnode->_prev = prev;
newnode->_next = pos;
pos->_prev = newnode;
}
private:
Node* _head;
};可以看到，在push_back(T&& x)中，调用insert函数时，必须使用forward将其原生属性保留下来，否则在后续的传递过程中，x会变为左值引用，这会使得前面的右值引用传递变得无效，这点在insert函数中同样有所体现，总结就是在传递右值引用参数时需要不断使用forward函数使其保持原生属性。
5.STL的变化
①新容器
C++11中新增的容器即用红框圈起来的几个，而比较有价值的容器只有unorder_set与unorder_map，array设计出来对标的是C语言中的数组，相比较而言唯一的优势可能是对数组越界的检查比较严格
②容器中的一些新接口
1.迭代器接口
新增了const版本的迭代器，但是本身使用begin也能够很好的解决问题，所以实际意义不大
2.所有容器均支持了{}列表初始化的构造函数
举几个例子
这使得我们初始化容器时更加方便，即可以用{}来初始化容器
3.所有容器均新增了emplace系列
这里使用了万能引用与可变模板参数，最终的目的是提高插入效率，它可以在容器的末尾直接构造一个元素，省去了先构造元素再插入的步骤，提高了效率。
4.容器新增了移动构造与移动赋值
有了移动构造与移动赋值之后，在某些场景下效率大大提升
6.类的变化
①默认成员函数
原来C++类中，有6个默认成员函数
1. 构造函数
2. 析构函数
3. 拷贝构造函数
4. 拷贝赋值重载
5. 取地址重载
6. const 取地址重载
C++11 新增了两个：移动构造函数和移动赋值运算符重载。需要注意的是
如果你没有自己实现移动构造函数，且没有实现析构函数 、拷贝构造、拷贝赋值重载中的任意一个。那么编译器会自动生成一个默认移动构造。默认生成的移动构造函数，对于内置类型成员会执行逐成员按字节拷贝，自定义类型成员，则需要看这个成员是否实现移动构造如果实现了就调用移动构造，没有实现就调用拷贝构造。
如果你没有自己实现移动赋值重载函数，且没有实现析构函数 、拷贝构造、拷贝赋值重载中的任意一个，那么编译器会自动生成一个默认移动赋值。默认生成的移动构造函数，对于内置类型成员会执行逐成员按字节拷贝，自定义类型成员，则需要看这个成员是否实现移动赋值，如果实现了就调用移动赋值，没有实现就调用拷贝赋值。(默认移动赋值跟上面移动构造完全类似)
如果你提供了移动构造或者移动赋值，编译器不会自动提供拷贝构造和拷贝赋值。
我们可以使用如下代码测试
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& operator=(const Person& p)
//{
//if(this != &p)
//{
//_name = p._name;
//_age = p._age;
//}
//return *this;
//}
//~Person()
//{}
private:
my_string::string _name;
int _age;
};
int main()
{
Person s1;
Person s2 = s1;
Person s3 = std::move(s1);
Person s4;
s4 = std::move(s2);
return 0;
}②类成员变量初始化
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;
private:
my_string::string _name;
int _age;
};
int main()
{
Person s1;
Person s2 = s1;
Person s3 = std::move(s1);
return 0;
}④禁止生成默认函数的关键字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;
private:
my_string::string _name;
int _age;
};
int main()
{
Person s1;
Person s2 = s1;
Person s3 = std::move(s1);
return 0;
}⑤继承和多态中的final与override关键字
这两个关键字在继承与多态中已经提到过，详见C++基础语法——继承。
7.可变参数模板
C++11的新特性可变参数模板能够让您创建可以接受可变参数的函数模板和类模板，相比C++98/03，类模版和函数模版中只能含固定数量的模版参数，可变模版参数无疑是一个巨大的改进。举个例子
// Args是一个模板参数包，args是一个函数形参参数包
// 声明一个参数包Args...args，这个参数包中可以包含0到任意个模板参数。
template <class ...Args>
void ShowList(Args... args)
{}上面的参数args前面有省略号，所以它就是一个可变模版参数，我们把带省略号的参数称为“参数包”，它里面包含了0到N（N>=0）个模版参数。我们无法直接获取参数包args中的每个参数的，只能通过展开参数包的方式来获取参数包中的每个参数，这是使用可变模版参数的一个主要特点，也是最大的难点，即如何展开可变模版参数。由于语法不支持使用args[i]这样方式获取可变参数，所以我们的用一些特殊的方法来获取参数包的值。
①使用递归函数方式展开参数包
举例代码如下
// 递归终止函数
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;
}这里的展开方式是每次获取一个value，然后将剩下的参数继续向后传，最终传到只有一个参数时终止
②使用逗号表达式展开参数包
这种展开参数包的方式，不需要通过递归终止函数，是直接在expand函数体中展开的, printarg不是一个递归终止函数，只是一个处理参数包中每一个参数的函数。这种就地展开参数包的方式实现的关键是逗号表达式。我们知道逗号表达式会按顺序执行逗号前面的表达式。
expand函数中的逗号表达式：(printarg(args), 0)，也是按照这个执行顺序，先执行printarg(args)，再得到逗号表达式的结果0。同时还用到了C++11的另外一个特性——初始化列表，通过初始化列表来初始化一个变长数组, {(printarg(args), 0)...}将会展开成((printarg(arg1),0), (printarg(arg2),0), (printarg(arg3),0), etc... )，最终会创建一个元素值都为0的数组int arr[sizeof...(Args)]。由于是逗号表达式，在创建数组的过程中会先执行逗号表达式前面的部分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;
}③STL中的emplace接口
template <class... Args>
void emplace_back(Args&&... args);首先我们看到的emplace系列的接口，支持模板的可变参数，并且万能引用。那么相对insert和
emplace系列接口的优势到底在哪里呢？
int main()
{
std::list< std::pair<int, char> > mylist;
// emplace_back支持可变参数，拿到构建pair对象的参数后自己去创建对象
// 那么在这里我们可以看到除了用法上，和push_back没什么太大的区别
mylist.emplace_back(10, 'a');
mylist.emplace_back(20, 'b');
mylist.emplace_back(make_pair(30, 'c'));
mylist.push_back(make_pair(40, 'd'));
mylist.push_back({ 50, 'e' });
for (auto e : mylist)
cout << e.first << ":" << e.second << endl;
return 0;
}int main()
{
// 下面我们试一下带有拷贝构造和移动构造的my_string::string，再试试呢
// 我们会发现其实差别也不到，emplace_back是直接构造了，push_back
// 是先构造，再移动构造，其实也还好。
std::list< std::pair<int, my_string::string> > mylist;
mylist.emplace_back(10, "sort");
mylist.emplace_back(make_pair(20, "sort"));
mylist.push_back(make_pair(30, "sort"));
mylist.push_back({ 40, "sort" });
return 0;
}即
8.lambda表达式
①C++98中的一种情况
在C++98中，如果想要对一个数据集合中的元素进行排序，可以使用std::sort方法。举个例子
int main()
{
int array[] = { 4,1,8,5,3,7,0,9,2,6 };
// 默认按照小于比较，排出来结果是升序
std::sort(array, array + sizeof(array) / sizeof(array[0]));
// 如果需要降序，需要改变元素的比较规则
std::sort(array, array + sizeof(array) / sizeof(array[0]), greater<int>());
return 0;
}如果待排序元素为自定义类型，需要我们自己定义排序时的比较规则，即
struct Goods
{
Goods(const char* str, double price, int evaluate)
:_name(str)
, _price(price)
, _evaluate(evaluate)
{}
string _name; // 名字
double _price; // 价格
int _evaluate; // 评价
};
struct ComparePriceLess
{
bool operator()(const Goods& gl, const Goods& gr)
{
return gl._price < gr._price;
}
};
struct ComparePriceGreater
{
bool operator()(const Goods& gl, const Goods& gr)
{
return gl._price > gr._price;
}
};
int main()
{
vector<Goods> v = { { "苹果", 2.1, 5 }, { "香蕉", 3, 4 }, { "橙子", 2.2,
3 }, { "菠萝", 1.5, 4 } };
sort(v.begin(), v.end(), ComparePriceLess());
sort(v.begin(), v.end(), ComparePriceGreater());
return 0;
}随着C++语法的发展，人们开始觉得上面的写法太复杂了，每次为了实现一个algorithm算法，都要重新去写一个类，如果每次比较的逻辑不一样，还要去实现多个类，特别是相同类的命名，这些都给编程者带来了极大的不便。因此，在C++11语法中出现了Lambda表达式。
②lambda表达式
下面的代码就是使用C++11中的lambda表达式来解决，可以看出lambda表达式实际是一个匿名函
数。
int main()
{
vector<Goods> v = { { "苹果", 2.1, 5 }, { "香蕉", 3, 4 }, { "橙子", 2.2,
3 }, { "菠萝", 1.5, 4 } };
sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2) {
return g1._price < g2._price; });
sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2) {
return g1._price > g2._price; });
sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2) {
return g1._evaluate < g2._evaluate; });
sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2) {
return g1._evaluate > g2._evaluate; });
return 0;
}③lambda表达式语法
lambda表达式书写格式：[capture-list] (parameters) mutable -> return-type { statement }
lambda表达式各部分说明
[capture-list] : 捕捉列表，该列表总是出现在lambda函数的开始位置，编译器根据[]来判断接下来的代码是否为lambda函数，捕捉列表能够捕捉上下文中的变量供lambda函数使用。
(parameters)：参数列表。与普通函数的参数列表一致，如果不需要参数传递，则可以连同()一起省略
mutable：默认情况下，lambda函数总是一个const函数，mutable可以取消其常量性。使用该修饰符时，参数列表不可省略(即使参数为空)。
->returntype：返回值类型。用追踪返回类型形式声明函数的返回值类型，没有返回值时此部分可省略。返回值类型明确情况下，也可省略，由编译器对返回类型进行推导。
{statement}：函数体。在该函数体内，除了可以使用其参数外，还可以使用所有捕获到的变量。
注：在lambda函数定义中，参数列表和返回值类型都是可选部分，而捕捉列表和函数体可以为
空。因此C++11中最简单的lambda函数为：[]{}; 该lambda函数不能做任何事情。
捕捉列表说明
捕捉列表描述了上下文中那些数据可以被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表达式之间不能相互赋值，即使看起来类型相同
下面我们就来举几个例子方便我们了解lambda表达式
// 例一
int main()
{
int a = 0, b = 2;
double rate = 2.555;
auto add1 = [](int x, int y)->int {return x + y; };
auto add2 = [](int x, int y) {return x + y; };
auto add3 = [rate](int x, int y) {return (x + y)* rate; };
cout << add1(a, b) << endl;
cout << add2(a, b) << endl;
cout << add3(a, b) << endl;
auto swap1 = [add1](int& x, int& y) {
int tmp = x;
x = y;
y = tmp;
cout << add1(x, y) << endl;
};
swap1(a, b);
return 0;
}// 例二
int main()
{
int x = 0, y = 2;
auto swap1 = [x, y]() mutable {
// mutable让捕捉的x和y可以改变了，
// 但是他们依旧是外面x和y的拷贝
int tmp = x;
x = y;
y = tmp;
};
swap1();
// 引用的方式捕捉
auto swap2 = [&x, &y](){
int tmp = x;
x = y;
y = tmp;
};
swap2();
int a = 0;
int b = 1;
int c = 2;
int d = 3;
const int e = 1;
cout << &e << endl;
// 引用的方式捕捉所有对象，除了a
// a用传值的方式捕捉
auto func = [&, a] {
//a++;
b++;
c++;
d++;
cout << &e << endl;
};
return 0;
}// 例三
int main()
{
auto f1 = [](int x, int y) {return x + y; };
auto f2 = [](int x, int y) {return x + y; };
//f1 = f2;
cout << typeid(f1).name() << endl;
cout << typeid(f2).name() << endl;
f1(1, 2);
return 0;
}
在这里f1看似等于f2，但它们的类型名称还是略有差异
④函数对象与lambda表达式
函数对象，又称为仿函数，即可以想函数一样使用的对象，就是在类中重载了operator()运算符的类对象。我们将其与lambda表达式做一个比较
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
auto r2 = [=](double monty, int year)->double {return monty * rate * year; };
r2(10000, 2);
return 0;
}查看其反汇编指令后我们可以发现
从使用方式上来看，函数对象与lambda表达式完全一样。实际在底层编译器对于lambda表达式的处理方式，完全就是按照函数对象的方式处理的，即：如果定义了一个lambda表达式，编译器会自动生成一个类，在该类中重载了operator()。
9.包装器
①function包装器
function包装器 也叫作适配器。C++中的function本质是一个类模板，也是一个包装器。那么我们来看看，我们为什么需要function呢？在 ret = func(x); 这个语句中的func可能是什么呢？func可能是函数名？函数指针？函数对象(仿函数对象)？也有可能是lambda表达式对象？所以这些都是可调用的类型，如此丰富的类型，可能会导致模板的效率低下
先看下面一段代码
template<class F, class T>
T useF(F f, T x)
{
static int count = 0;
cout << "count:" << ++count << endl;
cout << "count:" << &count << endl;
return f(x);
}
double f(double i)
{
return i / 2;
}
struct Functor
{
double operator()(double d)
{
return d / 3;
}
};
int main()
{
// 函数名
cout << useF(f, 11.11) << endl;
// 函数对象
cout << useF(Functor(), 11.11) << endl;
// lamber表达式
cout << useF([](double d)->double { return d / 4; }, 11.11) << endl;
return 0;
}运行后我们可以发现
通过上面的程序验证，我们会发现useF函数模板实例化了三份。而包装器可以很好的解决上面的问题，其类模板原型如下
template <class T> function; // undefined
template <class Ret, class... Args>
class function<Ret(Args...)>;注：Ret: 被调用函数的返回类型；Args…：被调用函数的形参
接下来举个例子
// 包装器 -- 可调用对象的类型问题
function<double(double)> f1 = f;
function<double(double)> f2 = [](double d)->double { return d / 4; };
function<double(double)> f3 = Functor();
//vector<function<double(double)>> v = { f1, f2, f3 };
vector<function<double(double)>> v = { f, [](double d)->double { return d / 4; }, Functor() };
double n = 3.3;
for (auto f : v)
{
cout << f(n++) << endl;
}既然如此，那么我们也可以利用包装器来解决之前的效率问题
int main()
{
// 函数名
std::function<double(double)> func1 = f;
cout << useF(func1, 11.11) << endl;
// 函数对象
std::function<double(double)> func2 = Functor();
cout << useF(func2, 11.11) << endl;
// lambda表达式
std::function<double(double)> func3 = [](double d)->double { return d / 4; };
cout << useF(func3, 11.11) << endl;
return 0;
}运行有
可以看到，在这里useF只实例化出了一份，提升了效率，此外它还可以应用到一些其他场景，举个例子，在逆波兰表达式求值 这道题中，没有学习包装器前我们使用的是switch case语句解决，即
class Solution {
public:
int evalRPN(vector<string>& tokens) {
stack<int> st;
for (auto& str : tokens)
{
if (str == "+" || str == "-" || str == "*" || str == "/")
{
int right = st.top();
st.pop();
int left = st.top();
st.pop();
switch (str[0])
{
case '+':
st.push(left + right);
break;
case '-':
st.push(left - right);
break;
case '*':
st.push(left * right);
break;
case '/':
st.push(left / right);
break;
}
}
else
{
st.push(stoi(str));
}
}
return st.top();
}
};而在学习了包装器之后，我们可以这样解决
class Solution {
public:
int evalRPN(vector<string>& tokens) {
stack<int> st;
map<string, function<int(int, int)>> opFuncMap =
{
{ "+", [](int i, int j) {return i + j; } },
{ "-", [](int i, int j) {return i - j; } },
{ "*", [](int i, int j) {return i * j; } },
{ "/", [](int i, int j) {return i / j; } }
};
for (auto& str : tokens)
{
if (opFuncMap.find(str) != opFuncMap.end())
{
int right = st.top();
st.pop();
int left = st.top();
st.pop();
st.push(opFuncMap[str](left, right));
}
else
{
st.push(stoi(str));
}
}
return st.top();
}
};②bind
std::bind函数定义在头文件中，是一个函数模板，它就像一个函数包装器(适配器)，接受一个可调用对象（callable object），生成一个新的可调用对象来“适应”原对象的参数列表。一般而言，我们用它可以把一个原本接收N个参数的函数fn，通过绑定一些参数，返回一个接收M个（M可以大于N，但这么做没什么意义）参数的新函数。同时，使用std::bind函数还可以实现参数顺序调整等操作。其原型如下
template <class Fn, class... Args>
/* unspecified */ bind (Fn&& fn, Args&&... args);
// with return type (2)
template <class Ret, class Fn, class... Args>
/* unspecified */ bind (Fn&& fn, Args&&... args);可以将bind函数看作是一个通用的函数适配器，它接受一个可调用对象，生成一个新的可调用对
象来“适应”原对象的参数列表。调用bind的一般形式：
auto newCallable = bind(callable,arg_list);
其中，newCallable本身是一个可调用对象，arg_list是一个逗号分隔的参数列表，对应给定的callable的参数。当我们调用newCallable时，newCallable会调用callable,并传给它arg_list中的参数。
arg_list中的参数可能包含形如_n的名字，其中n是一个整数，这些参数是“占位符”，表示newCallable的参数，它们占据了传递给newCallable的参数的“位置”。数值n表示生成的可调用对象中参数的位置：_1为newCallable的第一个参数，_2为第二个参数，以此类推。
让我们举几个例子
int Sub(int a, int b)
{
return a - b;
}
double Plus(int a, int b, double rate)
{
return (a + b) * rate;
}
double PPlus(int a, double rate, int b)
{
return rate * (a + b);
}
class Sub
{
public:
int sub(int a, int b)
{
return a - b;
}
};
class SubType
{
public:
static int sub(int a, int b)
{
return a - b;
}
int ssub(int a, int b, int rate)
{
return (a - b) * rate;
}
};
int main()
{
/*function<int(int, int)> rSub = bind(Sub, placeholders::_1, placeholders::_2);
cout << rSub(10, 5) << endl;*/
// int Sub(int a, int b)
function<int(int, int)> rSub = bind(Sub, placeholders::_2, placeholders::_1);
cout << rSub(10, 5) << endl;
// double Plus(int a, int b, double rate)
function<double(int, int)> Plus1 = bind(Plus, placeholders::_1, placeholders::_2, 4.0);
function<double(int, int)> Plus2 = bind(Plus, placeholders::_1, placeholders::_2, 4.2);
function<double(int, int)> Plus3 = bind(Plus, placeholders::_1, placeholders::_2, 4.4);
cout << Plus1(5, 3) << endl;
cout << Plus2(5, 3) << endl;
cout << Plus3(5, 3) << endl;
// double PPlus(int a, double rate, int b)
function<double(int, int)> PPlus1 = bind(PPlus, placeholders::_1, 4.0, placeholders::_2);
function<double(int, int)> PPlus2 = bind(PPlus, placeholders::_1, 4.2, placeholders::_2);
cout << PPlus1(5, 3) << endl;
cout << PPlus2(5, 3) << endl;
// static int sub(int a, int b)
function<double(int, int)> Sub1 = bind(&SubType::sub, placeholders::_1, placeholders::_2);
// int ssub(int a, int b, int rate)
SubType st;
function<double(int, int)> Sub2 = bind(&SubType::ssub, &st, placeholders::_1, placeholders::_2, 3);
cout << Sub1(1, 2) << endl;
cout << Sub2(1, 2) << endl;
function<double(int, int)> Sub3 = bind(&SubType::ssub, SubType(), placeholders::_1, placeholders::_2, 3);
cout << Sub3(1, 2) << endl;
cout << typeid(Sub3).name() << endl;
return 0;
}运行有
部分对应情况如图所示
bind函数可以在我们遇见一些自己不习惯或者感觉参数顺序不对时，按自己喜欢的方式来对应参数位置
