19，C++——11

目次

一、 C++11简介
二、 新增的列表初始化
三、 新增的STL容器
四、 简化声明
1，auto
2，decltype
3，nullptr
五、右值引用
1，左值引用和右值引用
2，两种引用的比力
3，左值引用的利用场景
4，右值引用的利用场景
5，完善转发
六、新增的类功能
1，原始默认成员函数
2，新增默认成员函数
3，关键字default
4，关键字delete
七、可变参数模板
1，语法格式
2，递归睁开
3，逗号表达式睁开
八、lambda表达式
1，数组元素排序
2，自界说类排序和lambda应用
3，lambda表达式的语法格式
4，捕获列表的语法格式
九、包装器
1，包装器的利用场景
2，包装器的语法格式
3，bind函数
点个赞吧！666

---

一、 C++11简介

在2003年C++标准委员会曾经提交了一份技能勘误表(简称TC1)，使得C++03这个名字已经取代了C++98称为C++11之前的最新C++标准名称。不外由于C++03(TC1)重要是对C++98标准中的弊端举行修复，语言的焦点部门则没有改动，因此人们风俗性的把两个标准归并称为C++98/03标准。
从C++0x到C++11，C++标准10年磨一剑，第二个真正意义上的标准珊珊来迟。相比于C++98/03，C++11则带来了数目可观的变革，此中包罗了约140个新特性，以及对C++03标准中约600个缺陷的修正，这使得C++11更像是从C++98/03中孕育出的一种新语言。
相比力而言，C++11能更好地用于体系开发和库开发、语法更加泛华和简单化、更加稳固和安全，不但功能更强盛，而且能提拔步调员的开发服从，公司现实项目开发中也用得比力多。
二、 新增的列表初始化

在C++98中，标准允许利用花括号{}对数组大概布局体元素，举行同一的列表初始值设定。
C++11中，扩大了用大括号括起的列表(初始化列表)的利用范围，使其可用于全部的内置范例和用户自界说的范例，利用初始化列表时，可添加等号(=)，也可不添加。
C++11中，利用列表初始化，会主动调用构造函数初始化，还实用于new表达式。

1. struct Point
2. {
3.         int _x;
4.         int _y;
5.         int _z;
6. };
8. class Date
9. {
10. public:
11.         Date(int year, int month, int day)
12.                 :_year(year)
13.                 , _month(month)
14.                 , _day(day)
15.         {
16.                 cout << "Date(int year, int month, int day)" << endl;
17.         }
18. private:
19.         int _year;
20.         int _month;
21.         int _day;
22. };
24. void test1()
25. {
26.         // C++98
27.         int arr1[] = { 1, 2, 3, 4, 5 };
28.         int arr2[5] = { 0 };
30.         Point p = { 1, 2 ,3 };
32.         Date d1(2022, 1, 1);
34.         // C++11
35.         int arr3[]{ 1, 2, 3, 4, 5 };
36.         int arr4[5]{ 0 };
38.         Point q{ 1, 2 ,3 };
40.         Date d2{ 2022, 1, 2 };
41.         Date d3 = { 2022, 1, 3 };
43.         int* pa = new int[4]{ 0 };
44.        
45. }

复制代码

三、 新增的STL容器

<array>和<forward_list>用的比力少，现实上最有用的是<unordered_map>和<unordered_set>
如果我们再细细去看会发现根本每个容器中都增长了一些C++11的方法，但是实在很多都是用得比力少的。
比如提供了cbegin和cend方法返回const迭代器等等，但是现实意义不大，由于begin和end也是可以返回const迭代器的，这些都是属于锦上添花的操纵。

四、 简化声明

C++11提供了多种简化声明的方式，尤其是在利用模板时。
1，auto

在C++98中auto是一个存储范例的分析符，表明变量是局部主动存储范例，但是局部域中界说局部的变量默认就是主动存储范例，以是auto就没什么代价了。C++11中废弃auto原来的用法，将其用于实现主动范例腿断。如许要求必须举行表现初始化，让编译器将界说对象的范例设置为初始化值的范例。

1. void test2()
2. {
3.         int i = 10;
4.         auto p = &i;
5.         auto pf = strcpy;
7.         cout << typeid(p).name() << endl;
8.         cout << typeid(pf).name() << endl;
10.         map<string, string> dict = { {"sort", "排序"}, {"insert", "插入"} };
11.         map<string, string>::iterator it = dict.begin();
12.         auto e = dict.begin();
13. }

复制代码

2，decltype

关键字decltype将变量的范例声明为表达式指定的范例。

1. template<class T1, class T2>
2. void F(T1 t1, T2 t2)
3. {
4.         decltype(t1 * t2) ret;
5.         cout << typeid(ret).name() << endl; // ret的类型是int
6. }
8. void test3()
9. {
10.         F(1, 'a');
12.         const int x = 1;
13.         double y = 2.2;
15.         decltype(x * y) ret;  // ret的类型是double
16.         decltype(&x) p;       // p的类型是int*
18.         cout << typeid(ret).name() << endl;
19.         cout << typeid(p).name() << endl;
20. }

复制代码

3，nullptr

由于C++中NULL被界说成字面量0，如许就大概回带来一些标题，由于0既能指针常量，又能体现整形常量。以是出于清晰和安全的角度思量，C++11中新增了nullptr，用于体现空指针。

1. #ifndef NULL
2. #ifdef __cplusplus
3. #define NULL   0
4. #else
5. #define NULL   ((void *)0)
6. #endif

复制代码

五、右值引用

1，左值引用和右值引用

传统的C++语法中就有引用的语法，而C++11中新增了的右值引用语法特性，之前利用的引用就叫做左值引用，无论左值引用还是右值引用，都是给对象取别名。
左值是一个体现数据的表达式(如变量名或解引用的指针)，我们可以获取它的所在+可以对它赋值，左值可以出现赋值符号的左边，右值不能出如今赋值符号左边。界说时const修饰符后的左值，不能给他赋值，但是可以取它的所在。
右值也是一个体现数据的表达式，如：字面常量、表达式返回值，函数返回值(这个不能是左值引用返回)等等，右值可以出如今赋值符号的右边，但是不能出现出如今赋值符号的左边，右值不能取所在。

1. void test4()
2. {
3.         // 以下的p、b、c、*p都是左值
4.         int* p = new int(0);
5.         int b = 1;
6.         const int c = 2;
8.         // 以下几个是对上面左值的左值引用
9.         int*& rp = p;
10.         int& rb = b;
11.         const int& rc = c;
12.         int& pvalue = *p;
14.         double x = 1.1, y = 2.2;
15.         // 以下几个都是常见的右值
16.         10;
17.         x + y;
18.         fmin(x, y);
20.         // 以下几个都是对右值的右值引用
21.         int&& rr1 = 10;
22.         double&& rr2 = x + y;
23.         double&& rr3 = fmin(x, y);
24. }

复制代码

2，两种引用的比力

左值引用总结：
1. 左值引用只能引用左值，不能引用右值。
2. 但是const左值引用既可引用左值，也可引用右值。
右值引用总结：
1. 右值引用只能右值，不能引用左值。
2. 但是右值引用可以move以后的左值。

1. void test5()
2. {
3.         // 左值引用只能引用左值，不能引用右值。
4.         int a = 10;
5.         int& ra1 = a;            // ra为a的别名
6.         // int& ra2 = 10;   // 编译失败，因为10是右值
7.        
8.         // const左值引用既可引用左值，也可引用右值。
9.         const int& ra3 = 10;
10.         const int& ra4 = a;
12.         // 右值引用只能右值，不能引用左值。
13.         int&& r1 = 10;
15.         // error C2440: “初始化”: 无法从“int”转换为“int &&”
16.         // message : 无法将左值绑定到右值引用
17.         int a = 10;
18.         int&& r2 = a;
20.         // 右值引用可以引用move以后的左值
21.         int&& r3 = std::move(a);
22. }

复制代码

3，左值引用的利用场景

1. void func1(bit::string s)
2. {}
3. void func2(const bit::string& s)
4. {}
5. int main()
6. {
7. bit::string s1("hello world");
9. // func1和func2的调用我们可以看到左值引用做参数减少了拷贝，提高效率的使用场景和价值
10. func1(s1);
11. func2(s1);
13. // string operator+=(char ch) 传值返回存在深拷贝
14. // string& operator+=(char ch) 传左值引用没有拷贝提高了效率
15. s1 += '!';
17. return 0;
18. }

复制代码

左值引用的短板：
但是当函数返回对象是一个局部变量，出了函数作用域就不存在了，就不能利用左值引用返回了， 只能利用传值返回。传值返回会导致至少1次拷贝构造(如果是一些旧一点的编译器大概是两次拷贝构造)。
4，右值引用的利用场景

右值引用可以补齐左值引用的短板。
移动构造本质是将参数右值的资源盗取过来，占位已有，那么就不消做深拷贝了，以是它叫做移动构造，就是盗取别人的资源来构造本身。
没有调用深拷贝的拷贝构造，而是调用了移动构造，移动构造中没有新开空间，拷贝数据，以是服从进步了。
不但仅有移动构造，另有移动赋值：
在string类中增长移动赋值函数，再去调用to_string(-6789)，不外这次是将to_string(-6789)返回的右值对象赋值给ret1对象，这时调用的是移动构造。

1. namespace ccc
2. {
3.         class string
4.         {
5.         public:
6.                 typedef char* iterator;
8.                 iterator begin()
9.                 {
10.                         return _str;
11.                 }
13.                 iterator end()
14.                 {
15.                         return _str + _size;
16.                 }
18.                 string(const char* str = "")
19.                         :_size(strlen(str))
20.                         , _capacity(_size)
21.                 {
22.                         //cout << "string(char* str)" << endl;
23.                         _str = new char[_capacity + 1];
24.                         strcpy(_str, str);
25.                 }
27.                 // s1.swap(s2)
28.                 void swap(string& s)
29.                 {
30.                         ::swap(_str, s._str);
31.                         ::swap(_size, s._size);
32.                         ::swap(_capacity, s._capacity);
33.                 }
35.                 // 拷贝构造
36.                 string(const string& s)
37.                         :_str(nullptr)
38.                 {
39.                         cout << "string(const string& s) -- 拷贝构造（深拷贝）" << endl;
40.                         string tmp(s._str);
41.                         swap(tmp);
42.                 }
44.                 // 移动构造
45.                 string(string&& s)
46.                         :_str(nullptr)
47.                         , _size(0)
48.                         , _capacity(0)
49.                 {
50.                         cout << "string(string&& s) -- 移动构造" << endl;
51.                         swap(s);
52.                 }
54.                 // 拷贝赋值重载
55.                 string& operator=(const string& s)
56.                 {
57.                         cout << "string& operator=(string s) -- 拷贝赋值（深拷贝）" << endl;
58.                         string tmp(s);
59.                         swap(tmp);
60.                         return *this;
61.                 }
63.                 // 移动赋值重载
64.                 string& operator=(string&& s)
65.                 {
66.                         cout << "string& operator=(string&& s) -- 移动赋值" << endl;
67.                         swap(s);
68.                         return *this;
69.                 }
71.                 ~string()
72.                 {
73.                         //cout << "~string()" << endl;
74.                         delete[] _str;
75.                         _str = nullptr;
76.                 }
78.                 char& operator[](size_t pos)
79.                 {
80.                         assert(pos < _size);
81.                         return _str[pos];
82.                 }
84.                 void reserve(size_t n)
85.                 {
86.                         if (n > _capacity)
87.                         {
88.                                 char* tmp = new char[n + 1];
89.                                 strcpy(tmp, _str);
90.                                 delete[] _str;
91.                                 _str = tmp;
92.                                 _capacity = n;
93.                         }
94.                 }
96.                 void push_back(char ch)
97.                 {
98.                         if (_size >= _capacity)
99.                         {
100.                                 size_t newcapacity = _capacity == 0 ? 4 : _capacity * 2;
101.                                 reserve(newcapacity);
102.                         }
103.                         _str[_size] = ch;
104.                         ++_size;
105.                         _str[_size] = '\0';
106.                 }
108.                 //string operator+=(char ch)
109.                 string& operator+=(char ch)
110.                 {
111.                         push_back(ch);
112.                         return *this;
113.                 }
115.                 const char* c_str() const
116.                 {
117.                         return _str;
118.                 }
120.         private:
121.                 char* _str;
122.                 size_t _size;
123.                 size_t _capacity; // 不包含最后做标识的\0
124.         };
125. }
127. ccc::string to_string(int val)
128. {
129.         bool flag = true;
130.         if (val < 0)
131.         {
132.                 flag = false;
133.                 val = 0 - val;
134.         }
136.         ccc::string str;
137.         while (val > 0)
138.         {
139.                 int x = val % 10;
140.                 val = val / 10;
141.                 str += ('0' + x);
142.         }
144.         if (flag == false)
145.         {
146.                 str += '-';
147.         }
149.         std::reverse(str.begin(), str.end());
150.         return str;
151. }
153. void test5()
154. {
155.         // 编译器会优化，减少临时拷贝
156.         ccc::string ret_1 = to_string(-2345);
158.         cout << endl << endl;
160.         // 左值引用，可以获取它的地址 + 可以对它赋值
161.         // 右值引用，不能获取地址，只能获得值
162.         ccc::string ret_2;
163.         ret_2 = to_string(-6789);
165.         cout << endl << endl;
167.         // 左值引用，就是要深拷贝，开辟空间再释放
168.         // 右值引用，就是把将亡值，直接拿过来使用
169.         ccc::string str1("hello");
170.         ccc::string str2(str1);
171.         ccc::string str3(move(str1));
172. }
174. void test6()
175. {
176.         ccc::string ret;
177.         ret = to_string(-6789);
178. }

复制代码

5，完善转发

模板中的&&不代表右值引用，而是万能引用，其既能汲取左值又能汲取右值。
模板的万能引用只是提供了可以或许汲取同时汲取左值引用和右值引用的本事，
但是引用范例的唯一作用就是限定了汲取的范例，后续利用中都退化成了左值，
我们渴望可以或许在通报过程中保持它的左值大概右值的属性, 就必要用到完善转发。
std::forward 完善转发能在传参的过程中生存对象原生范例属性

1. void Fun(int& x) { cout << "左值引用" << endl; }
2. void Fun(const int& x) { cout << "const 左值引用" << endl; }
3. void Fun(int&& x) { cout << "右值引用" << endl; }
4. void Fun(const int&& x) { cout << "const 右值引用" << endl; }
6. template<typename T>
7. void PerfectForward(T&& t)
8. {
9.         Fun(std::forward<T>(t));
10. }
12. void test8()
13. {
14.         PerfectForward(10);                          // 右值
16.         int a;
17.         PerfectForward(a);                          // 左值
18.         PerfectForward(std::move(a)); // 右值
20.         const int b = 8;
21.         PerfectForward(b);                          // const 左值
22.         PerfectForward(std::move(b)); // const 右值
23. }

复制代码

六、新增的类功能

1，原始默认成员函数

原来C++类中，有6个默认成员函数：
1. 构造函数
2. 析构函数
3. 拷贝构造函数
4. 拷贝赋值重载
5. 取所在重载
6. const 取所在重载
2，新增默认成员函数

而C++11 新增了两个：移动构造函数，移动赋值运算符重载
针对移动构造函数和移动赋值运算符重载有一些必要注意的点如下：
1.如果你没有本身实现移动构造函数，且没有实现析构函数 、拷贝构造、拷贝赋值重载中的恣意一个。那么编译器会主动天生一个默认移动构造。默认天生的移动构造函数，对于内置范例成员会实行逐成员按字节拷贝，自界说范例成员，则必要看这个成员是否实现移动构造，如果实现了就调用移动构造，没有实现就调用拷贝构造。
2.如果你没有本身实现移动赋值重载函数，且没有实现析构函数 、拷贝构造、拷贝赋值重载中的恣意一个，那么编译器会主动天生一个默认移动赋值。默认天生的移动构造函数，对于内置范例成员会实行逐成员按字节拷贝，自界说范例成员，则必要看这个成员是否实现移动赋值，如果实现了就调用移动赋值，没有实现就调用拷贝赋值。(默认移动赋值跟上面移动构造完全雷同)
3.如果你提供了移动构造大概移动赋值，编译器不会主动提供拷贝构造和拷贝赋值。
3，关键字default

欺压天生默认函数的关键字default:
C++11可以让你更好的控制要利用的默认函数。
假设你要利用某个默认的函数，但是由于一些缘故起因这个函数没有默认天生。
比如：我们提供了拷贝构造，就不会天生移动构造了，那么我们可以利用default关键字表现指定移动构造天生
4，关键字delete

克制天生默认函数的关键字delete:
如果能想要限定某些默认函数的天生，在C++98中，是该函数设置成private，而且只声明补丁已，如许只要其他人想要调用就会报错。
在C++11中更简单，只需在该函数声明加上=delete即可，该语法指示编译器不天生对应函数的默认版本，称=delete修饰的函数为删除函数。

1. class Person
2. {
3. public:
4.         Person(const char* name = "", int age = 0)
5.                 :_name(name)
6.                 , _age(age)
7.         {}
9.         Person(const Person& p)
10.                 :_name(p._name)
11.                 , _age(p._age)
12.         {}
14.         Person(Person&& p) = default;
16.         //Person(const Person& p) = delete;
17. private:
18.         ccc::string _name;
19.         int _age;
20. };
22. void test9()
23. {
24.         Person s1;
25.         Person s2 = s1;
26.         Person s3 = std::move(s1);
27. }

复制代码

七、可变参数模板

1，语法格式

C++11的新特性可变参数模板，能创建继承可变参数的函数模板和类模板，相比 C++98/03，类模版和函数模版中只能含固定命目的模版参数，可变模版参数无疑是一个巨大的改进。
可变参数函数的语法格式

1. // Args是一个模板参数包，args是一个函数形参参数包
2. // 声明一个参数包Args...args，这个参数包中可以包含0到任意个模板参数。
3. template <class ...Args>
4. void ShowList(Args... args)
5. {}

复制代码

上面的参数args前面有省略号，以是它就是一个可变模版参数，我们把带省略号的参数称为“参数包”，它内里包罗了0到N（N>=0）个模版参数。
我们无法直接获取参数包args中的每个参数的，只能通过睁开参数包的方式来获取参数包中的每个参数，这是利用可变模版参数的一个重要特点，也是最大的难点，即怎样睁开可变模版参数。
由于语法不支持利用args如许方式获取可变参数，以是我们的用一些奇招来逐一获取参数包的值。
2，递归睁开

递归函数方式睁开参数包

1. // 递归终止函数
2. template <class T>
3. void ShowList(const T& t)
4. {
5. cout << t << endl;
6. }
8. // 展开函数
9. template <class T, class ...Args>
10. void ShowList(T value, Args... args)
11. {
12. cout << value <<" ";
13. ShowList(args...);
14. }
16. int main()
17. {
18. ShowList(1);
19. ShowList(1, 'A');
20. ShowList(1, 'A', std::string("sort"));
22. return 0;
23. }

复制代码

3，逗号表达式睁开

逗号表达式睁开参数包

1. template <class T>
2. void PrintArg(T t)
3. {
4. cout << t << " ";
5. }
7. //展开函数
8. template <class ...Args>
9. void ShowList(Args... args)
10. {
11. int arr[] = { (PrintArg(args), 0)... };
12. cout << endl;
13. }
14. int main()
15. {
16. ShowList(1);
17. ShowList(1, 'A');
18. ShowList(1, 'A', std::string("sort"));
19. return 0;
20. }

复制代码

八、lambda表达式

1，数组元素排序

1. void test12()
2. {
3.         // C++98
4.         int array[] = { 4,1,8,5,3,7,0,9,2,6 };
5.         for (auto e : array) { cout << e << " "; }
6.         cout << endl;
8.         // 默认按照小于比较，排出来结果是升序
9.         std::sort(array, array + sizeof(array) / sizeof(array[0]));
10.         for (auto e : array) { cout << e << " "; }
11.         cout << endl;
13.         // 如果需要降序，需要改变元素的比较规则
14.         std::sort(array, array + sizeof(array) / sizeof(array[0]), greater<int>());
15.         for (auto e : array) { cout << e << " "; }
16.         cout << endl;
17. }

复制代码

2，自界说类排序和lambda应用

1. struct Goods
2. {
3.         string _name;  // 名字
4.         double _price; // 价格
5.         int _evaluate; // 评价
6.         Goods(const char* str, double price, int evaluate)
7.                 :_name(str)
8.                 , _price(price)
9.                 , _evaluate(evaluate)
10.         {}
11. };
12. struct ComparePriceLess
13. {
14.         bool operator()(const Goods& gl, const Goods& gr)
15.         {
16.                 return gl._price < gr._price;
17.         }
18. };
19. struct ComparePriceGreater
20. {
21.         bool operator()(const Goods& gl, const Goods& gr)
22.         {
23.                 return gl._price > gr._price;
24.         }
25. };
27. void test13()
28. {
29.         //C++98排序，需要调用类成员函数
30.         vector<Goods> v = { { "苹果", 2.1, 5 }, { "香蕉", 3, 4 }, { "橙子", 2.2, 3 }, { "菠萝", 1.5, 4 } };
31.         sort(v.begin(), v.end(), ComparePriceLess());
32.         sort(v.begin(), v.end(), ComparePriceGreater());
34.         //C++11排序，可以使用lambda表达式
35.         vector<Goods> v2 = { { "苹果", 2.1, 5 }, { "香蕉", 3, 4 }, { "橙子", 2.2,3 }, { "菠萝", 1.5, 4 } };
36.         sort(v.begin(), v2.end(), [](const Goods& g1, const Goods& g2) {return g1._price < g2._price; });
37.         sort(v.begin(), v2.end(), [](const Goods& g1, const Goods& g2) {return g1._price > g2._price; });
38.         sort(v.begin(), v2.end(), [](const Goods& g1, const Goods& g2) {return g1._evaluate < g2._evaluate; });
39.         sort(v.begin(), v2.end(), [](const Goods& g1, const Goods& g2) {return g1._evaluate > g2._evaluate; });
40. }

复制代码

3，lambda表达式的语法格式

lambda表达式誊写格式为：
[capture-list] (parameters) mutable -> return-type { statement }
lambda表达式各部门分析：
[capture-list] : 捕获列表，该列表总是出如今lambda函数的开始位置，编译器根据[]来 判定接下来的代码是否为lambda函数，捕获列表可以或许捕获上下文中的变量供lambda 函数利用。
(parameters)：参数列表。与平凡函数的参数列表同等，如果不必要参数通报，则可以 连同()一起省略 。
mutable：取消常性性，默认情况下，lambda函数总是一个const函数，mutable可以取消其常量性。利用该修饰符时，参数列表不可省略(纵然参数为空)。
->returntype：返回值范例。用追踪返回范例情势声明函数的返回值范例，没有返回值时此部门可省略。返回值范例明白情况下，也可省略，由编译器对返回范例举行推导。
{statement}：函数体。在该函数体内，除了可以利用其参数外，还可以利用全部捕获到的变量。

1. void test14()
2. {
3.         // 最简单的lambda表达式, 该lambda表达式没有任何意义
4.         [] {};
6.         // 省略参数列表和返回值类型，返回值类型由编译器推导为int
7.         int a = 3, b = 4;
8.         [=] {return a + 3; };
10.         // 省略了返回值类型，无返回值类型
11.         auto fun1 = [&](int c) {b = a + c; };
12.         fun1(10);
13.         cout << a << " " << b << endl;
15.         // 各部分都很完善的lambda函数
16.         auto fun2 = [=, &b](int c)->int {return b += a + c; };
17.         cout << fun2(10) << endl;
19.         // 复制捕捉x
20.         int x = 10;
21.         auto add_x = [x](int a) mutable { x *= 2; return a + x; };
22.         cout << add_x(10) << endl;
23. }
25. void (*PF)();
26. void test15()
27. {
28.         auto f1 = [] {cout << "hello world" << endl; };
29.         auto f2 = [] {cout << "hello world" << endl; };
31.         //f1 = f2;   // 编译失败--->提示找不到operator=()
32.         auto f3(f2);
33.         f3();
35.         // 可以将lambda表达式赋值给相同类型的函数指针
36.         PF = f2;
37.         PF();
38. }

复制代码

4，捕获列表的语法格式

捕获列表形貌了上下文中那些数据可以被lambda利用，利用的方式为传值还是传引用。
[var]：体现值通报方式捕获变量var
[=]：体现值通报方式捕获全部父作用域中的变量(包罗this)
[&var]：体现引用通报捕获变量var
[&]：体现引用通报捕获全部父作用域中的变量(包罗this)
[this]：体现值通报方式捕获当前的this指针
注意：
a. 父作用域指包罗lambda函数的语句块
b. 语法上捕获列表可由多个捕获项构成，并以逗号分割
比如：[=, &a, &b]: 以引用通报的方式捕获a和b，值通报的方式捕获其他全部变量
c. 捕获列表不允许变量重复通报，否则就会导致编译错误
比如：[=，a]: 已经以传值的方式捕获了全部变量，捕获a重复会导致报错
d. 在块作用域以外的lambda函数捕获列表必须为空
e. lambda表达式之间不能相互赋值，纵然看起来范例雷同

1. void test16()
2. {
3.         int a, b, c, d, e;
4.         a = b = c = d = e = 1;
6.         // 传值捕捉
7.         auto f1 = [=]()
8.         {
9.                 cout << a << b << c << d << e << endl;
10.         };
11.         f1();
13.         // 引用捕捉
14.         auto f2 = [&]()
15.         {
16.                 cout << a << b << c << d << e << endl;
17.         };
18.         f2();
20.         // 混合捕捉
21.         auto f3 = [=, &a]() //以引用传递的方式捕捉变量a，值传递方式捕捉其他所有变量
22.         {
23.                 a++;
24.                 cout << a << b << c << d << e << endl;
25.         };
26.         f3();
28.         // 混合捕捉
29.         auto f4 = [&, a]() //值传递方式捕捉变量a，引用方式捕捉其他变量
30.         {
31.                 //a++; 值传递捕捉，无法修改变量值
32.                 b++;
33.                 c++;
34.                 d++;
35.                 e++;
36.                 cout << a << b << c << d << e << endl;
37.         };
38.         f4();
39. }

复制代码

九、包装器

1，包装器的利用场景

function包装器也叫作适配器。C++中的function本质是一个类模板，也是一个包装器。 那么我们来看看，我们为什么必要function呢？
由于function可以镌汰函数模板实例化。包装前，useF函数模板实例化了三份；包装后，useF函数模板实例化了一份。

1. double func(double d)
2. {
3.         return d / 2;
4. }
6. int add(int a, int b)
7. {
8.         return a + b;
9. }
11. struct Functor
12. {
13.         double operator()(double d)
14.         {
15.                 return d / 3;
16.         }
17.         int operator() (int a, int b)
18.         {
19.                 return a + b;
20.         }
21. };
23. class Plus
24. {
25. public:
26.         static int plusi(int a, int b)
27.         {
28.                 return a + b;
29.         }
30.         double plusd(double a, double b)
31.         {
32.                 return a + b;
33.         }
34. };
36. void test17()
37. {
38.         //包装前，实例化3次
39.         // 函数名
40.         cout << useF(func, 11.11) << endl;
41.         // 函数对象（仿函数）
42.         cout << useF(Functor(), 11.11) << endl;
43.         // lamber表达式
44.         cout << useF([](double d)->double { return d / 4; }, 11.11) << endl;
46.         //包装后，只实例化1次
47.   // 函数名
48.         function<double(double)> f1 = func;
49.         cout << useF(f1, 11.11) << endl;
50.         // 函数对象（仿函数）
51.         function<double(double)> f2 = Functor();
52.         cout << useF(f2, 11.11) << endl;
53.   // lamber表达式
54.         function<double(double)> f3 = [](double d)->double { return d / 4; };
55.         cout << useF(f3, 11.11) << endl;
56. }
58. void test18()
59. {
60.         function<int(int, int)> f1 = add;
61.         f1(1, 2);
63.         function<int(int, int)> f2 = Functor();
64.         f2(1, 2);
66.         function<int(int, int)> f3 = Plus::plusi;
67.         f3(1, 2);
69.         function<double(Plus, double, double)> f4 = &Plus::plusd;
70.         f4(Plus(), 1.1, 2.2);
71. }

复制代码

2，包装器的语法格式

1. #include <functional>
3. // 类模板原型如下
4. template <class T> function;   // undefined
6. template <class Ret, class... Args>
7. class function<Ret(Args...)>;
9. 模板参数说明：
10. Ret: 被调用函数的返回类型
11. Args…：被调用函数的形参

复制代码

3，bind函数

std::bind函数界说在头文件中，是一个函数模板，它就像一个函数包装器(适配器)，继承一个可调用对象（callable object），天生一个新的可调用对象来“顺应”原对象的参数列表。
一样寻常而言，我们用它可以把一个原来汲取N个参数的函数fn，通过绑定一些参数，返回一个汲取M个（M可以大于N，但这么做没什么意义）参数的新函数。同时，利用std::bind函数还可以实现参数次序调解等操纵。
语法原型如下：

1. // 原型如下：
2. template <class Fn, class... Args>
3. /* unspecified */ bind (Fn&& fn, Args&&... args);
5. // with return type (2)
6. template <class Ret, class Fn, class... Args>
7. /* 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为第二个参数，以此类推。

1. int Div(int a, int b)
2. {
3.         return a / b;
4. }
6. int Add(int a, int b)
7. {
8.         return a + b;
9. }
11. int Mul(int a, int b, int rate)
12. {
13.         return a * b * rate;
14. }
16. class Sub
17. {
18. public:
19.         int sub(int a, int b)
20.         {
21.                 return a - b;
22.         }
23. };
25. void test19()
26. {
27.         int x = 2;
28.         int y = 10;
29.         cout << Div(x, y) << endl;
31.         // 调整顺序
32.         auto bindFunc1 = bind(Div, placeholders::_1, placeholders::_2);
33.         cout << bindFunc1(x, y) << endl;
35.         function<int(int, int)> bindFunc2 = bind(Div, placeholders::_2, placeholders::_1);
36.         cout << bindFunc2(x, y) << endl;
38.         //调整个数，绑定死固定参数
39.         function<int(int, int)> funcAdd = Add;
40.         function<int(int, int)> funcSub = bind(&Sub::sub, Sub(), placeholders::_1, placeholders::_2);
41.         function<int(int, int)> funcMul = bind(Mul, placeholders::_1, placeholders::_2, 6);
43.         map<string, function<int(int, int)>> ofFuncMap =
44.         {
45.                 {"+", Add},
46.                 {"-", bind(&Sub::sub, Sub(), placeholders::_1, placeholders::_2)},
47.         };
49.         cout << funcAdd(1, 2) << endl;
50.         cout << funcSub(1, 2) << endl;
51.         cout << funcMul(2, 1) << endl;
52.         cout << ofFuncMap["+"](1, 2) << endl;
53.         cout << ofFuncMap["-"](1, 2) << endl;
54. }

复制代码

点个赞吧！666