C++11先容

目录
一、C++11的两个小点
1.1、decltype
1.2、nullptr
二、列表初始化
2.1、C++98传统的{}
2.2、C++11中的{}
2.3、C++11中的std::initializer_list
三、右值引用和移动语义
3.1、左值和右值
3.2、左值引用和右值引用
3.3、引用延伸生命周期
3.4、左值和右值的参数匹配
3.5、右值引用和移动语义的使用场景
3.5.1、左值引用主要使用场景回顾
3.5.2、移动构造和移动赋值
3.5.3、右值引⽤和移动语义办理传值返回问题
3.5.4、右值引⽤和移动语义在传参中的提效
3.6类型分类
3.7、折叠引用
3.8、完美转发
四、可变参数模版
4.1、根本语法及原理
4.2、包扩展
4.3、emplace系列接口
五、新的类功能
5.1、默认的移动构造和移动赋值
5.2、defult和delete
六、lambda
6.1、lambda表达式语法
6.2、捕捉列表
6.3、lambda的应⽤
6.4、lambda的原理
七、包装器
7.1、function
7.2、bind

---

一、C++11的两个小点

1.1、decltype

关键字decltype将变量的类型声明为表达式指定的类型。如图：

1.2、nullptr

由于C++中NULL被定义为字面量0，这样大概会带来一些问题，因为0既能表现指针常量，又能表现整型常量，以是出于清晰和安全的角度考虑，C++11中新增了nullptr，用于表现空指针。
二、列表初始化

2.1、C++98传统的{}

C++98中⼀般数组和结构体可以⽤{}进⾏初始化。如图：

2.2、C++11中的{}

• C++11以后想统⼀初始化⽅式，试图实现⼀切对象皆可⽤{}初始化，{}初始化也叫做列表初始化。
  
• 内置类型⽀持，⾃定义类型也⽀持，⾃定义类型本质是类型转换，中间会产⽣临时对象，最后优化了以后变成直接构造。
  
• {}初始化的过程中，可以省略掉=。
  
• C++11列表初始化的本意是想实现⼀个⼤统⼀的初始化⽅式，其次他在有些场景下带来的不少便利，如容器push/inset多参数构造的对象时，{}初始化会很⽅便。
  

示例代码：

1. class Date
2. {
3. public:
4.         Date(int year = 1, int month = 1, int day = 1)
5.                 :_year(year)
6.                 , _month(month)
7.                 , _day(day)
8.         {
9.                 cout << "Date(int year, int month, int day)" << endl;
10.         }
11.         Date(const Date& d)
12.                 :_year(d._year)
13.                 , _month(d._month)
14.                 , _day(d._day)
15.         {
16.                 cout << "Date(const Date& d)" << endl;
17.         }
18. private:
19.         int _year;
20.         int _month;
21.         int _day;
22. };
24. int main()
25. {
26.         // C++98⽀持的
27.         int a1[] = { 1, 2, 3, 4, 5 };
28.         int a2[5] = { 0 };
29.         Point p = { 1, 2 };
31.         // C++11支持的
32.         // 内置类型支持
33.         int x1 = { 2 };
35.         // ⾃定义类型支持
36.         // 这⾥本质是⽤{ 2025, 1, 1}构造⼀个Date临时对象
37.         // 临时对象再去拷⻉构造d1，编译器优化后合⼆为⼀变成{ 2025, 1, 1}直接构造初始化
38.         // 运⾏⼀下，我们可以验证上⾯的理论，发现是没调⽤拷⻉构造的
39.         Date d1 = { 2025, 1, 1 };
41.         // 这⾥d2引⽤的是{ 2024, 7, 25 }构造的临时对象,临时对象有常性
42.         const Date& d2 = { 2024, 7, 25 };
44.         // 需要注意的是C++98⽀持单参数时类型转换，也可以不⽤{}
45.         Date d3 = { 2025 };
46.         Date d4 = 2025;
48.         // 可以省略掉=
49.         Point p1{ 1, 2 };
50.         int x2{ 2 };
51.         Date d6{ 2024, 7, 25 };
52.         const Date& d7{ 2024, 7, 25 };
54.         // 下面语句不支持，只有{}初始化，才能省略=
55.         // Date d8 2025;
57.         vector<Date> v;
58.         v.push_back(d1);
59.         v.push_back(Date(2025, 1, 1));
60.         // ⽐起有名对象和匿名对象传参，这⾥{}更有性价⽐
61.         v.push_back({ 2025, 1, 1 });
62.         return 0;
63. }

复制代码

2.3、C++11中的std::initializer_list

• 上⾯的初始化已经很⽅便，但是对象容器初始化还是不太⽅便，⽐如⼀个vector对象，我想⽤N个值去构造初始化，那么我们得实现许多个构造函数才能⽀持。而initializer_list可以让一个构造函数接受任意个数的参数，如：vector<int> v1 = {1,2,3}; vector<int> v2 = {1,2,3,4,5};
  
• C++11库中提出了⼀个std::initializer_list的类，auto il = { 10, 20, 30 };// the type of il is an initializer_list，这个类的本质是底层开⼀个数组，将数据拷⻉到数组中，std::initializer_list内部不直接存储数组的数据，而是有两个指针分别指向数组的开始和结束。
  
• 这是它的⽂档：initializer_list - C++ Reference，std::initializer_list⽀持迭代器遍历。
  
• 容器⽀持⼀个std::initializer_list的构造函数，也就⽀持任意多个值构成的{x1,x2,x3...} 进⾏初始化。STL中的容器⽀持任意多个值构成的{x1,x2,x3...}进⾏初始化，就是通过 std::initializer_list的构造函数⽀持的。
  

如图：（这里只截取了vector和list）
vector：

list：

示例代码：

三、右值引用和移动语义

C++98的C++语法中就有引⽤的语法，⽽C++11中新增了的右值引⽤语法特性，C++11之后我们之前学习的引⽤就叫做左值引⽤。⽆论左值引⽤还是右值引⽤，都是给对象取别名。
3.1、左值和右值

• 左值是⼀个表⽰数据的表达式(如变量名或解引⽤的指针)，⼀般是有恒久状态，存储在内存中，我们可以获取它的地点，左值可以出现赋值符号的左边，也可以出现在赋值符号右边。定义时const 修饰符后的左值，不能给他赋值，但是可以取它的地点。
  
• 右值也是⼀个表⽰数据的表达式，要么是字⾯值常量、要么是表达式求值过程中创建的临时对象 等，右值可以出现在赋值符号的右边，但是不能出现出现在赋值符号的左边，右值不能取地点。
  
• 值得⼀提的是，左值的英⽂简写为lvalue，右值的英⽂简写为rvalue。传统认为它们分别是left value、right value 的缩写。当代C++中，lvalue 被解释为loactor value的缩写，可意为存储在内存中、有明确存储地点可以取地点的对象，⽽ rvalue 被解释为 read value，指的是那些可以提供数据值，但是不可以寻址，例如：临时变量，字⾯量常量，存储于寄存器中的变量等，也就是说左值和右值的核⼼区别就是能否取地点。
  

注意：引用了右值的变量的属性是左值。例如：int&& r1 = 10；10是右值，但是r1是左值。
示例代码：

1. int main()
2. {
3.         // 左值：可以取地址
4.         // 以下的p、b、c、*p、s、s[0]就是常⻅的左值
5.         int* p = new int(0);
6.         int b = 1;
7.         const int c = b;
8.         *p = 10;
9.         string s("111111");
10.         s[0] = 'x';
11.         cout << &c << endl;
12.         cout << (void*)&s[0] << endl;
14.         // 右值：不能取地址
15.         double x = 1.1, y = 2.2;
16.         // 以下⼏个10、x + y、fmin(x, y)、string("11111")都是常⻅的右值
17.         10;
18.         x + y;
19.         fmin(x, y);
20.         string("11111");
22.         //右值取地址会报错
23.         //cout << &10 << endl;
24.         //cout << &(x+y) << endl;
25.         //cout << &(fmin(x, y)) << endl;
26.         //cout << &string("11111") << endl;
28.         return 0;
29. }

复制代码

3.2、左值引用和右值引用

• Type& r1 = x;  Type&& rr1 = y;第⼀个语句就是左值引⽤，左值引⽤就是给左值取别名，第⼆个就是右值引⽤，同样的原理，右值引⽤就是给右值取别名。
  
• 左值引⽤不能直接引⽤右值，但是const左值引⽤可以引⽤右值。
  
• 右值引⽤不能直接引⽤左值，但是右值引⽤可以引⽤move(左值)。
  
• template <class T> typename remove_reference<T>::type&& move (T&& arg);
  
• move是库⾥⾯的⼀个函数模板，本质内部是进⾏强制类型转换，当然他还涉及⼀些引⽤折叠的知识，这个下面会细讲。
  
• 需要注意的是变量表达式都是左值属性，也就意味着⼀个右值被右值引⽤绑定后，右值引⽤变量的变量表达式的属性是左值
  
• 语法层⾯看，左值引⽤和右值引⽤都是取别名，不开空间。从汇编底层的⻆度看下⾯代码中r1和rr1 汇编层实现，底层都是⽤指针实现的，没什么区别。底层汇编等实现和上层语法表达的意义偶然是背离的，以是不要⼀起去理解，互相佐证，这样反⽽是陷⼊迷途。
  

move声明：

示例代码：

1. int main()
2. {
3.         // 左值：可以取地址
4.         // 以下的p、b、c、*p、s、s[0]就是常⻅的左值
5.         int* p = new int(0);
6.         int b = 1;
7.         const int c = b;
8.         *p = 10;
9.         string s("111111");
10.         s[0] = 'x';
11.         double x = 1.1, y = 2.2;
13.         // 左值引⽤给左值取别名
14.         int& r1 = b;
15.         int*& r2 = p;
16.         int& r3 = *p;
17.         string& r4 = s;
18.         char& r5 = s[0];
20.         // 右值引⽤给右值取别名
21.         int&& rr1 = 10;
22.         double&& rr2 = x + y;
23.         double&& rr3 = fmin(x, y);
24.         string&& rr4 = string("11111");
26.         // 左值引⽤不能直接引⽤右值，但是const左值引⽤可以引⽤右值
27.         const int& rx1 = 10;
28.         const double& rx2 = x + y;
29.         const double& rx3 = fmin(x, y);
30.         const string& rx4 = string("11111");
32.         // 右值引⽤不能直接引⽤左值，但是右值引⽤可以引⽤move(左值)
33.         int&& rrx1 = move(b);
34.         int*&& rrx2 = move(p);
35.         int&& rrx3 = move(*p);
36.         string&& rrx4 = move(s);
38.         //底层(汇编层面)并不分左值引用和右值引用，在底层它们都是一样的
39.         //语法上通不过是因为上层封装时将他们封装为不同类型
40.         //编译器检测语法时，因为类型不同报错
41.         //所以只要强转成相同类型就可以了，move的本质也是在强转
42.         string&& rrx5 = (string&&)s;
44.         // b、r1、rr1都是变量表达式，都是左值
45.         cout << &b << endl;
46.         cout << &r1 << endl;
47.         cout << &rr1 << endl;
48.         // 这⾥要注意的是，rr1的属性是左值，所以不能再被右值引⽤绑定，除非move⼀下
49.         int& r6 = r1;
50.         // int&& rrx6 = rr1;
51.         int&& rrx6 = move(rr1);
53.         return 0;
54. }

复制代码

注意：右值底层实在是有地点的，但是在语法层取不到。
3.3、引用延伸生命周期

右值引⽤可⽤于为临时对象延⻓⽣命周期，const 的左值引⽤也能延⻓临时对象⽣存期，但这些对象⽆法被修改。

上图中，r3引用的是右值，但是r3自己的属性是左值，以是可以延伸临时对象的生命周期。
3.4、左值和右值的参数匹配

• C++98中，我们实现⼀个const左值引⽤作为参数的函数，那么实参传递左值和右值都可以匹配。
  
• C++11以后，分别重载左值引⽤、const左值引⽤、右值引⽤作为形参的 f 函数，那么实参是左值会匹配 f (左值引⽤)，实参是const左值会匹配 f (const 左值引⽤)，实参是右值会匹配f(右值引⽤)。
  
• 右值引⽤变量在⽤于表达式时属性是左值，这个设计这⾥会感觉跟怪，后面我们讲右值引⽤的使⽤场景时，就能体会这样设计的代价了。
  

示例代码：

1. void f(int& x)
2. {
3.         std::cout << "左值引用重载 f(" << x << ")\n";
4. }
6. void f(const int& x)
7. {
8.         std::cout << "const 的左值引用重载 f(" << x << ")\n";
9. }
11. void f(int&& x)
12. {
13.         std::cout << "右值引用重载 f(" << x << ")\n";
14. }
16. int main()
17. {
18.         int i = 1;
19.         const int ci = 2;
20.         f(i); // 调用 f(int&)
21.         f(ci); // 调用 f(const int&)
22.         f(3); // 调用 f(int&&)，如果没有 f(int&&) 重载则会调用 f(const int&)
23.         f(std::move(i)); // 调用 f(int&&)
24.         // 右值引用变量在用于表达式时是左值
25.         int&& x = 1;
26.         f(x); // 调用 f(int& x)
27.         f(std::move(x)); // 调用 f(int&& x)
28.         return 0;
29. }

复制代码

结果：

3.5、右值引用和移动语义的使用场景

3.5.1、左值引用主要使用场景回顾

左值引⽤主要使⽤场景是在函数中左值引⽤传参和左值引⽤传返回值时减少拷⻉，同时还可以修改实参和修改返回对象的代价。左值引⽤已经办理⼤多数场景的拷⻉效率问题，但是有些场景不能使⽤传左值引⽤返回，如下面addStrings和generate函数，C++98中的办理⽅案只能是被迫使⽤输出型参数办理。那么C++11以后这⾥可以使⽤右值引⽤做返回值办理吗？显然是不大概的，因为这⾥的本质是返回对象是⼀个局部对象，函数结束这个对象就析构销毁了，右值引⽤返回也⽆法改变对象已经析构销毁的究竟。
代码：

1. class Solution
2. {
3. public:
4.         // 传值返回需要拷贝
5.         string addStrings(string num1, string num2)
6.         {
7.                 string str;
8.                 int end1 = num1.size() - 1, end2 = num2.size() - 1;
9.                 // 进位
10.                 int next = 0;
11.                 while (end1 >= 0 || end2 >= 0)
12.                 {
13.                         int val1 = end1 >= 0 ? num1[end1--] - '0' : 0;
14.                         int val2 = end2 >= 0 ? num2[end2--] - '0' : 0;
15.                         int ret = val1 + val2 + next;
16.                         next = ret / 10;
17.                         ret = ret % 10;
18.                         str += ('0' + ret);
19.                 }
20.                 if (next == 1)
21.                         str += '1';
22.                 reverse(str.begin(), str.end());
23.                 return str;
24.         }
25. };
27. class Solution
28. {
29. public:
30.         // 这里的传值返回拷⻉代价就太大了
31.         vector<vector<int>> generate(int numRows)
32.         {
33.                 vector<vector<int>> vv(numRows);
34.                 for (int i = 0; i < numRows; ++i)
35.                 {
36.                         vv[i].resize(i + 1, 1);
37.                 }
38.                 for (int i = 2; i < numRows; ++i)
39.                 {
40.                         for (int j = 1; j < i; ++j)
41.                         {
42.                                 vv[i][j] = vv[i - 1][j] + vv[i - 1][j - 1];
43.                         }
44.                 }
45.                 return vv;
46.         }
47. };

复制代码

3.5.2、移动构造和移动赋值

• 移动构造函数是⼀种构造函数，类似拷⻉构造函数，移动构造函数要求第⼀个参数是该类类型的引⽤，但是差别的是要求这个参数是右值引⽤，如果另有其他参数，额外的参数必须有缺省值。
  
• 移动赋值是⼀个赋值运算符的重载，他跟拷⻉赋值构成函数重载，类似拷⻉赋值函数，移动赋值函数要求第⼀个参数是该类类型的引⽤，但是差别的是要求这个参数是右值引⽤。
  
• 对于像string/vector这样的深拷⻉的类大概包罗深拷⻉的成员变量的类，移动构造和移动赋值才故意义，因为移动构造和移动赋值的第⼀个参数都是右值引⽤的类型，他的本质是要“窃取”引⽤的右值对象的资源，⽽不是像拷⻉构造和拷⻉赋值那样去拷⻉资源，从提⾼效率。下⾯的bit::string 样例实现了移动构造和移动赋值，我们需要联合场景理解。
  

示例代码：

1. namespace bit
2. {
3.         class string
4.         {
5.         public:
6.                 typedef char* iterator;
7.                 typedef const char* const_iterator;
8.                 iterator begin()
9.                 {
10.                         return _str;
11.                 }
13.                 iterator end()
14.                 {
15.                         return _str + _size;
16.                 }
18.                 const_iterator begin() const
19.                 {
20.                         return _str;
21.                 }
23.                 const_iterator end() const
24.                 {
25.                         return _str + _size;
26.                 }
28.                 string(const char* str = "")
29.                         :_size(strlen(str))
30.                         , _capacity(_size)
31.                 {
32.                         cout << "string(char* str)-构造" << endl;
33.                         _str = new char[_capacity + 1];
34.                         strcpy(_str, str);
35.                 }
37.                 void swap(string& s)
38.                 {
39.                         ::swap(_str, s._str);
40.                         ::swap(_size, s._size);
41.                         ::swap(_capacity, s._capacity);
42.                 }
44.                 //拷贝构造
45.                 string(const string& s)
46.                         :_str(nullptr)
47.                 {
48.                         cout << "string(const string& s) -- 拷⻉构造" << endl;
49.                         reserve(s._capacity);
50.                         for (auto ch : s)
51.                         {
52.                                 push_back(ch);
53.                         }
54.                 }
56.                 // 移动构造
57.                 //传入的是临时创建的对象，即将亡值，不能取地址，用完就会消亡
58.                 //所以直接交换资源
59.                 string(string&& s)
60.                 {
61.                         cout << "string(string&& s) -- 移动构造" << endl;
62.                         swap(s);
63.                 }
65.                 string& operator=(const string& s)
66.                 {
67.                         cout << "string& operator=(const string& s) -- 拷⻉赋值" <<
68.                                 endl;
69.                         if (this != &s)
70.                         {
71.                                 _str[0] = '\0';
72.                                 _size = 0;
73.                                 reserve(s._capacity);
74.                                 for (auto ch : s)
75.                                 {
76.                                         push_back(ch);
77.                                 }
78.                         }
79.                         return *this;
80.                 }
82.                 // 移动赋值
83.                 string& operator=(string&& s)
84.                 {
85.                         cout << "string& operator=(string&& s) -- 移动赋值" << endl;
86.                         swap(s);
87.                         return *this;
88.                 }
90.                 ~string()
91.                 {
92.                         cout << "~string() -- 析构" << endl;
93.                         delete[] _str;
94.                         _str = nullptr;
95.                 }
96.                 char& operator[](size_t pos)
97.                 {
98.                         assert(pos < _size);
99.                         return _str[pos];
100.                 }
101.                 void reserve(size_t n)
102.                 {
103.                         if (n > _capacity)
104.                         {
105.                                 char* tmp = new char[n + 1];
106.                                 if (_str)
107.                                 {
108.                                         strcpy(tmp, _str);
109.                                         delete[] _str;
110.                                 }
111.                                 _str = tmp;
112.                                 _capacity = n;
113.                         }
114.                 }
115.                 void push_back(char ch)
116.                 {
117.                         if (_size >= _capacity)
118.                         {
119.                                 size_t newcapacity = _capacity == 0 ? 4 : _capacity *
121.                                         2;
122.                                 reserve(newcapacity);
123.                         }
124.                         _str[_size] = ch;
125.                         ++_size;
126.                         _str[_size] = '\0';
127.                 }
128.                 string& operator+=(char ch)
129.                 {
130.                         push_back(ch);
131.                         return *this;
132.                 }
133.                 const char* c_str() const
135.                 {
136.                         return _str;
137.                 }
138.                 size_t size() const
140.                 {
141.                         return _size;
142.                 }
143.         private:
144.                  char* _str = nullptr;
145.                  size_t _size = 0;
146.                  size_t _capacity = 0;
147.         };
148. }

复制代码

3.5.3、右值引⽤和移动语义办理传值返回问题

注意：下面所有测试都基于上面实现的string类。
右值对象构造，只有拷⻉构造，没有移动构造的场景：
图1展⽰了vs2019 debug环境下编译器对拷⻉的优化，左边为不优化的情况下，两次拷⻉构造，右 边为编译器优化的场景下一连步骤中的拷⻉合⼆为⼀变为⼀次拷⻉构造。
需要注意的是在vs2019的release和vs2022的debug和release，下⾯代码优化为⾮常可怕，会直接 将str对象的构造，str拷⻉构造临时对象，临时对象拷⻉构造ret对象，合三为⼀，变为直接构造。 变为直接构造。要理解这个优化要联合局部对象⽣命周期和栈帧的⻆度理解，如图3所⽰。
linux下可以将下⾯代码拷⻉到test.cpp⽂件，编译时⽤ g++ test.cpp -fno-elide-constructors 的⽅式关闭构造优化，运⾏结果可以看到图1左边没有优化的两次拷⻉。
图一：

右值对象构造，有拷⻉构造，也有移动构造的场景：
图2展⽰了vs2019 debug环境下编译器对拷⻉的优化，左边为不优化的情况下，两次移动构造，右 边为编译器优化的场景下一连步骤中的拷⻉合⼆为⼀变为⼀次移动构造。
需要注意的是在vs2019的release和vs2022的debug和release，下⾯代码优化为⾮常可怕，会直接 将str对象的构造，str拷⻉构造临时对象，临时对象拷⻉构造ret对象，合三为⼀，变为直接构造。 要理解这个优化要联合局部对象⽣命周期和栈帧的⻆度理解，如图3所⽰。
linux下可以将下⾯代码拷⻉到test.cpp⽂件，编译时⽤ g++ test.cpp -fno-elide-constructors 的⽅式关闭构造优化，运⾏结果可以看到图1左边没有优化的两次移动。
图二：

图三：

右值对象赋值，只有拷⻉构造和拷⻉赋值，没有移动构造和移动赋值的场景：
图4左边展⽰了vs2019 debug和 g++ test.cpp -fno-elide-constructors 关闭优化环境下编译器的处理，⼀次拷⻉构造，⼀次拷⻉赋值。
需要注意的是在vs2019的release和vs2022的debug和release，下⾯代码会进⼀步优化，直接构造 要返回的临时对象，str本质是临时对象的引⽤，底层⻆度⽤指针实现。运⾏结果的⻆度，我们可以 看到str的析构是在赋值以后，阐明str就是临时对象的别名。
图四：

右值对象赋值，既有拷⻉构造和拷⻉赋值，也有移动构造和移动赋值的场景：
图5左边展⽰了vs2019 debug和 g++ test.cpp -fno-elide-constructors 关闭优化环境下编译器的处理，⼀次移动构造，⼀次移动赋值。
需要注意的是在vs2019的release和vs2022的debug和release，下⾯代码会进⼀步优化，直接构造 要返回的临时对象，str本质是临时对象的引⽤，底层⻆度⽤指针实现。运⾏结果的⻆度，我们可以 看到str的析构是在赋值以后，阐明str就是临时对象的别名。
图五：

总结：如果传入的是右值，对于自定义类型而言，右值又叫将亡值，使用之后就会死亡，以是没有必要举行拷贝浪费效率，直接转移资源即可，即直接互换数据(例如通过swap），如果是左值大概就需要举行深拷贝了。
3.5.4、右值引⽤和移动语义在传参中的提效

   检察STL⽂档我们发现C++11以后容器的push和insert系列的接⼝否增加的右值引⽤版本。
  例如：

   

• 当实参是⼀个左值时，容器内部继续调⽤拷⻉构造进⾏拷⻉，将对象拷⻉到容器空间中的对象。
  
• 当实参是⼀个右值，容器内部则调⽤移动构造，右值对象的资源到容器空间的对象上。
  
• 把我们之前模拟实现的 list 拷⻉过来，实现右值引⽤参数版本的push_back和insert。
  

  实当代码：

1.                 //右值版本的insert
2.                 iterator insert(iterator pos, T&& x)
3.                 {
4.                         Node* cur = pos._node;
5.                         Node* newnode = new Node(move(x));
6.                         Node* prev = cur->_prev;
8.                         // prev  newnode  cur
9.                         prev->_next = newnode;
10.                         newnode->_prev = prev;
11.                         newnode->_next = cur;
12.                         cur->_prev = newnode;
14.                         return iterator(newnode);
15.                 }
16.                 //右值版本的push_back
17.                 void push_back(T&& x)
18.                 {
19.                         insert(end(), move(x));
20.                 }

复制代码

这里有一个注意点：引用了右值的变量的属性实在是左值，也就是说，对于一个变量，固然它引用的是右值，但是他自己是左值，以是这里只是将这两个方法的形参改为吸收右值的情势是不敷的，例如：push_back的右值版本的方法中，如果只将形参改为能够吸收右值，其他不变，那么形参x引用的是右值，但x自己实在是左值，那么在方法内部调用insert方法时就会因为x是左值而调用左值对应的insert方法，而不是右值对应的insert方法，对于这种情况，我们有两种方法办理，第一种是完美转发，下面会先容，这里使用第二种，因为这个方法内部我们是知道我们吸收的是右值的，以是向下传递时将该变量move一下，将其转换为右值，当然，这样做所有对应调到的方法都要有右值版本才行，而且每次向下传递时都要move一下。
代码美满：（仅右值相干部门）

1.                 //节点的构造方法-右值版本
2.                 ListNode(T&& data)
3.                         :_next(nullptr)
4.                         , _prev(nullptr)
5.                         , _data(move(data))
6.                 {}

复制代码

解释：需要这个方法是因为在insert方法中通过右值直接构造节点。
   实在这⾥另有⼀个emplace系列的接⼝，但是这个涉及可变参数模板，我们需要把可变参数模板讲解以后再讲解emplace系列的接⼝。
  3.6类型分类

C++11以后，进⼀步对类型进⾏了分别，右值被分别纯右值(pure value，简称prvalue)和将亡值 (expiring value，简称xvalue)。
纯右值是指那些字⾯值常量或求值结果相当于字⾯值或是⼀个不具名的临时对象。如：42、true、nullptr 大概类似 str.substr(1, 2)、str1 + str2 传值返回函数调⽤，大概整形a、b，a++，a+b等。纯右值和将亡值C++11中提出的，C++11中的纯右值概念分别等价于 C++98中的右值。（即内置类型的右值叫做纯右值）
将亡值是指返回右值引⽤的函数的调⽤表达式和转换为右值引⽤的转换函数的调⽤表达，如 move(x)、static_cast(x)。（即自定义类型的右值叫做将亡值）
泛左值(generalized value，简称glvalue)，泛左值包罗将亡值和左值。
两个关于值类型的中⽂和英⽂的官⽅⽂档，有兴 趣可以相识细节：
https://zh.cppreference.com/w/cpp/language/value_categoryhttps://zh.cppreference.com/w/cpp/language/value_category

3.7、折叠引用

   C++中不能直接定义引⽤的引⽤如 int& && r = i;，这样写会直接报错，通过模板或 typedef 中的类型操纵可以构成引⽤的引⽤。 通过模板或 typedef 中的类型操纵构成引⽤的引⽤时，这时C++11给出了⼀个引⽤折叠的规则：右值引⽤的右值引⽤折叠成右值引⽤，所有其他组合均折叠成左值引⽤。
  下⾯的步伐中很好的展⽰了模板和typedef时构成引⽤的引⽤时的引⽤折叠规则。

• 像PerfectForward这样的函数模板中，T&& x参数看起来是右值引⽤参数，但是由于引⽤折叠的规则，他传递左值时就是左值引⽤，传递右值时就是右值引⽤，有些地⽅也把这种函数模板的参数叫做全能引⽤。
  
• Function(T&& t)函数模板步伐中，假设实参是int右值，模板参数T的推导int，实参是int左值，模板参数T的推导int&，再联合引⽤折叠规则，就实现了当实参是左值时，就实例化出左值引⽤版本形参的Function，实参是右值时，就实例化出右值引⽤版本形参的Function。
  

从上面代码可以看到，无论是右值还是左值都可以调用该模版函数，且实际使用中，传入左值就会天生左值版本的函数，传入右值就会天生右值版本的函数，这就是引用折叠。对于函数而言，平常函数和使用了类的模版的成员函数都无法实现引用折叠，想要实现引用折叠，函数必须有自己的模版参数。例如：

上图是稍加改动后的从前模拟实现的list，这个成员函数就只是右值版本的函数，不是引用折叠，因为它的模版是 list 这个类的，不是自己的，当类实例化时，这个模版参数就定下来了，他就没法根据传入的参数在去实例化差别的左值和右值的版本。
3.8、完美转发

PerfectForward(T&& t)函数模板步伐中，传左值实例化以后是左值引⽤的PerfectForward函数，传右值实例化以后是右值引⽤的PerfectForward函数。
但是联合我们在前面的讲解，变量表达式都是左值属性，也就意味着⼀个右值被右值引⽤绑定 后，右值引⽤变量表达式的属性是左值，也就是说PerfectForward函数中t的属性是左值，那么我们把t传递给下⼀层函数Fun，那么匹配的都是左值引⽤版本的Fun函数。这⾥我们想要保持t对象的属性， 就需要使⽤完美转发实现。
   完美转发声明：
  template <class T> T&& forward (typename remove_reference<T>::type& arg);
  template <class T> T&& forward (typename remove_reference<T>::type&& arg);
  完美转发forward本质是⼀个函数模板，他主要还是通过引⽤折叠的⽅式实现，下⾯⽰例中传递给 PerfectForward的实参是右值，T被推导为int，没有折叠，forward内部t被强转为右值引⽤返回；传递给 PerfectForward的实参是左值，T被推导为int&，引⽤折叠为左值引⽤，forward内部t被强转为左值引⽤返回。

四、可变参数模版

4.1、根本语法及原理

C++11⽀持可变参数模板，也就是说⽀持可变数量参数的函数模板和类模板，可变数⽬的参数被称 为参数包，存在两种参数包：模板参数包，表⽰零或多个模板参数；函数参数包：表⽰零或多个函 数参数。
   template <class  ...Args> void Func(Args... args) {}
  template <class  ...Args> void Func(Args&... args) {}
  template <class  ...Args> void Func(Args&&... args) {}
  我们⽤省略号来指出⼀个模板参数或函数参数的表⽰⼀个包，在模板参数列表中，class...或 typename...指出接下来的参数表⽰零或多个类型列表；在函数参数列表中，类型名后⾯跟...指出 接下来表⽰零或多个形参对象列表；函数参数包可以⽤左值引⽤或右值引⽤表⽰，跟前⾯平常模板 ⼀样，每个参数实例化时遵照引⽤折叠规则。
可变参数模板的原理跟模板类似，本质还是去实例化对应类型和个数的多个函数。
这⾥我们可以使⽤sizeof...(参数包)方式去盘算参数包中参数的个数。
示例代码一：

1. void Print()
2. {
3.         cout << endl;
4. }
6. //参数包传入时第一个参数解析到x中
7. //然后再递归依次进行解析
8. template <class T, class ...Args>
9. void Print(T&& x, Args&&... args)
10. {
11.         //不可以这样结束递归
12.         //因为这样是运行时结束递归的方式
13.         //但是解析参数包时编译时解析的，所以需要提供一个空参的函数来结束编译时递归
14.         //if (sizeof...(args) == 0)
15.         //        return;
17.         cout << x << " ";
18.         Print(args...);
19. }
21. // 可变模版参数
22. // 参数类型可变
23. // 参数个数可变
24. template <class ...Args>
25. void ShowList(Args... args)
26. {
27.         //计算参数包的参数个数
28.         cout << sizeof...(args) << endl;
30. // 可变参数模版在编译时解析
31. // 下面是运行获取和解析，所以不支持这样用
32. //        /*cout << sizeof...(args) << endl;
33. //        for (size_t i = 0; i < sizeof...(args); i++)
34. //        {
35. //                cout << args[i] << " ";
36. //        }
38.         //正确解析方式
39.         Print(args...);
40. }
42. int main()
43. {
44.         //下面这些调用方式都可以
45.         ShowList();
46.         ShowList(1);
47.         ShowList(1, "xxxxx");
48.         ShowList(1, "xxxxx", 2.2);
50.         return 0;
51. }

复制代码

示例代码二：

1. template <class T>
2. int PrintArg(T t)
3. {
4.         cout << t << " ";
5.         //借助数组解析，但是返回值会被放入数组中
6.         //所以返回int类型的0，符合数组存储数据的类型
7.         //当然也可以不返回该类型的数据，那就需要用到逗号表达式
8.         return 0;
9. }
11. template <class ...Args>
12. void ShowList(Args... args)
13. {
14.         //借助数组来帮助我们解析参数包
15.         //返回值会放到数组中
16.         int arr[] = { PrintArg(args)... };
18.         //如果函数返回值和数组类型不相符可以这样
19.         // 通过逗号表达式，最终放入数组中的是0
20.         //int arr[] = { (PrintArg(args),0)...};
21.        
22.         cout << endl;
23. }
25. //编译推演生成下面的函数
26. //void ShowList(int x, char y, std::string z)
27. //{
28. //        int arr[] = { PrintArg(x),PrintArg(y),PrintArg(z) };
29. //        cout << endl;
30. //}
32. //这样也可以
33. //template <class ...Args>
34. //void ShowList(Args... args)
35. //{
36. // //这里必须用逗号表达式，因为cout返回的类型是ostream的
37. //        int arr[] = { (cout<<(args)<<" ", 0)...};
38. //
39. //        cout << endl;
40. //}
42. int main()
43. {
44.         ShowList(1, 'A', std::string("sort"));
46.         return 0;
47. }

复制代码

4.2、包扩展

对于⼀个参数包，我们除了能盘算他的参数个数，我们能做的唯⼀的事情就是扩展它，当扩展⼀个 包时，我们还要提供⽤于每个扩展元素的模式，扩展⼀个包就是将它分解为构成的元素，对每个元 素应⽤模式，获得扩展后的列表。我们通过在模式的右边放⼀个省略号(...)来触发扩展操纵。底层 的实现细节如图1所⽰。
C++还⽀持更复杂的包扩展，直接将参数包依次展开依次作为实参给⼀个函数行止理。

4.3、emplace系列接口

   template <class...  Args> void emplace_back (Args&&...  args);
  template <class...  Args> iterator emplace (const_iterator position, Args&&...  args);
  

• C++11以后STL容器新增了empalce系列的接⼝，empalce系列的接⼝均为模板可变参数，功能上兼容push和insert系列，但是empalce还⽀持新玩法，假设容器为container，empalce还⽀持直接插⼊构造T对象的参数，这样有些场景会更⾼效⼀些，可以直接在容器空间上构造T对象。
  
• emplace_back总体⽽⾔是更⾼效，推荐以后使⽤emplace系列替换insert和push系列。
  
• 第⼆个步伐中我们模拟实现了list的emplace和emplace_back接⼝，这⾥把参数包不段往下传递， 终极在结点的构造中直接去匹配容器存储的数据类型T的构造，以是达到了前⾯说的empalce⽀持直接插⼊构造T对象的参数，这样有些场景会更⾼效⼀些，可以直接在容器空间上构造T对象。
  
• 传递参数包过程中，如果是Args&&...  args的参数包，要⽤完美转发参数包，⽅式如下：std::forward<Args>(args)...，否则编译时包扩展后右值引⽤变量表达式就变成了左值。
  

示例代码一：(使用)

1. // emplace_back总体而言是更高效，推荐使用
2. int main()
3. {
4.         //基本使用和push_xxx/insert方法类似
5.         //这里使用的是前面我们自己实现的string，方便我们看效果
6.         list<bit::string> lt;
7.         // 左值
8.         bit::string s1("111111111111");
9.         lt.emplace_back(s1);
11.         // 右值
12.         lt.emplace_back(move(s1));
14.         list<pair<bit::string, int>> lt1;
15.         // 构造pair + 拷贝/移动构造pair到list的节点中data上
16.         pair<bit::string, int> kv("苹果", 1);
17.         lt1.emplace_back(kv);
18.         lt1.emplace_back(move(kv));
19.         cout << endl << endl;
22.         // 不同点
23.         // 直接把构造pair参数包往下传，直接用pair参数包构造pair
24.         lt1.emplace_back("苹果", 1);
25.         cout << endl;
27.         // 直接把构造string参数包往下传，直接用string参数包构造string
28.         lt.emplace_back("111111111111");
29.         //使用的构造函数：string(int n, const char ch)
30.         lt.emplace_back(10, 'x');
31.         cout << endl << endl;
33.         return 0;
34. }

复制代码

结果：

示例代码二：（emplace_back实现）

1.                 //节点的构造函数  ListNode
2.                 template<class... Args>
3.                 ListNode(Args... args)
4.                         :_next(nullptr)
5.                         , _prev(nullptr)
6.                         , _data(forward<Args>(args)...)
7.                 {}
10.         //list
11.                 template<class... Args>
12.                 iterator insert(iterator pos, Args&&... args)
13.                 {
14.                         Node* cur = pos._node;
15.                         Node* newnode = new Node(forward<Args>(args)...);
16.                         Node* prev = cur->_prev;
18.                         // prev  newnode  cur
19.                         prev->_next = newnode;
20.                         newnode->_prev = prev;
21.                         newnode->_next = cur;
22.                         cur->_prev = newnode;
24.                         return iterator(newnode);
25.                 }
27.                 template<class... Args>
28.                 void emplace_back(Args&&... args)
29.                 {
30.                         insert(end(), forward<Args>(args)...);
31.                 }

复制代码

五、新的类功能

5.1、默认的移动构造和移动赋值

• 原来C++类中，有6个默认成员函数：构造函数/析构函数/拷⻉构造函数/拷⻉赋值重载/取地点重 载/const 取地点重载，最后重要的是前4个，后两个⽤处不⼤，默认成员函数就是我们不写编译器 会⽣成⼀个默认的。C++11 新增了两个默认成员函数，移动构造函数和移动赋值运算符重载。
  
• 如果你没有⾃⼰实现移动构造函数，且没有实现析构函数、拷⻉构造、拷⻉赋值重载中的任意⼀ 个。那么编译器会⾃动⽣成⼀个默认移动构造。默认⽣成的移动构造函数，对于内置类型成员会执⾏逐成员按字节拷⻉，⾃定义类型成员，则需要看这个成员是否实现移动构造，如果实现了就调⽤移动构造，没有实现就调⽤拷⻉构造。
  
• 如果你没有⾃⼰实现移动赋值重载函数，且没有实现析构函数、拷⻉构造、拷⻉赋值重载中的任意⼀个，那么编译器会⾃动⽣成⼀个默认移动赋值。默认⽣成的移动赋值函数，对于内置类型成员会执⾏逐成员按字节拷⻉，⾃定义类型成员，则需要看这个成员是否实现移动赋值，如果实现了就调⽤移动赋值，没有实现就调⽤拷⻉赋值。(默认移动赋值跟上⾯移动构造完全类似)。
  
• 如果你提供了移动构造大概移动赋值，编译器不会⾃动提供拷⻉构造和拷⻉赋值。以是如果强制天生默认的移动构造和移动赋值，就必须自动实现拷贝构造和拷贝赋值。
  

5.2、defult和delete

• C++11可以让你更好的控制要使⽤的默认函数。假设你要使⽤某个默认的函数，但是因为⼀些缘故原由这个函数没有默认⽣成。⽐如：我们提供了拷⻉构造，就不会⽣成移动构造了，那么我们可以使⽤default关键字强制移动构造的⽣成。
  
• 如果能想要限制某些默认函数的⽣成，在C++98中，是该函数设置成private，而且只声明不定义， 这样只要其他⼈想要调⽤就会报错。在C++11中更简朴，只需在该函数声明加上=delete即可，该语法指⽰编译器不⽣成对应函数的默认版本，称=delete修饰的函数为删除函数。
  

六、lambda

6.1、lambda表达式语法

   lambda 表达式本质是⼀个匿名函数对象，跟平常函数差别的是他可以定义在函数内部。
  lambda 表达式语法使⽤层⽽⾔没有类型，以是我们⼀般是⽤auto大概模板参数定义的对象去吸收 lambda 对象。
  lambda表达式的格式： [capture-list] (parameters)-> return type { function boby }：

• [capture-list] :捕捉列表，该列表总是出现在 lambda 函数的开始位置，编译器根据 [ ] 来判断接下来的代码是否为 lambda 函数，捕捉列表能够捕捉上下⽂中的变量供 lambda 函数使⽤，捕捉列表可以传值和传引⽤捕捉，捕捉列表为空也不能省略。
  
• (parameters) ：参数列表，与平常函数的参数列表功能类似，如果不需要参数传递，则可以连同()⼀起省略。
  
• ->return type ：返回值类型，⽤追踪返回类型情势声明函数的返回值类型，没有返回值时此部门可省略。⼀般返回值类型明确情况下，也可省略，由编译器对返回类型进⾏推导。
  
• {function boby} ：函数体，函数体内的实现跟平常函数完全类似，在该函数体内，除了可以使⽤其参数外，还可以使⽤所有捕获到的变量，函数体为空也不能省略。
  

6.2、捕捉列表

lambda 表达式中默认只能⽤ lambda 函数体和参数中的变量，如果想⽤外层作⽤域中的变量就需要进⾏捕捉。捕获的三种方式如下：

• 第⼀种捕捉⽅式是在捕捉列表中显⽰的传值捕捉和传引⽤捕捉，捕捉的多个变量⽤逗号分割。[x， y，&z] 表⽰x和y值捕捉，z引⽤捕捉。
  
• 第⼆种捕捉⽅式是在捕捉列表中隐式捕捉，我们在捕捉列表写⼀个=表⽰隐式值捕捉，在捕捉列表写⼀个&表⽰隐式引⽤捕捉，这样我们 lambda 表达式中⽤了那些变量，编译器就会⾃动捕捉那些变量。
  
• 第三种捕捉⽅式是在捕捉列表中混合使⽤隐式捕捉和显⽰捕捉。[=, &x]表⽰其他变量隐式值捕捉， x引⽤捕捉；[&, x, y]表⽰其他变量引⽤捕捉，x和y值捕捉。当使⽤混合捕捉时，第⼀个元素必须是 &或=，而且&混合捕捉时，后⾯的捕捉变量必须是值捕捉，同理=混合捕捉时，后⾯的捕捉变量必须是引⽤捕捉。
  

   捕获列表详细阐明：
  捕获列表形貌了上下文中哪些数据可以被lambda使用，以及使用的方式是传值还是传引用。
  [var]：表现值传递方式捕获变量var。默认会被const修饰
  [=]：表现值传递方式捕获所有父作用域中的变量(包括this)。
  [&var]：表现引用传递捕获变量var。
  [&]：表现引用传递捕获所有父作用域中的变量(包括this)。
   lambda 表达式如果在函数局部域中，他可以捕捉 lambda 位置之前定义的变量，不能捕捉静态局部变量和全局变量，静态局部变量和全局变量也不需要捕捉， lambda 表达式中可以直接使⽤。这也意味着 lambda 表达式如果定义在全局位置，捕捉列表必须为空。
默认情况下， lambda 捕捉列表是被const修饰的，也就是说传值捕捉的过来的对象不能修改， mutable加在参数列表的后⾯可以取消其常量性，也就说使⽤该修饰符后，传值捕捉的对象就可以 修改了，但是修改还是形参对象，不会影响实参。使⽤该修饰符后，参数列表不可省略(纵然参数为空)。
6.3、lambda的应⽤

在学习 lambda 表达式之前，我们的使⽤的可调⽤对象只有函数指针和仿函数对象，函数指针的类型定义起来⽐较麻烦，仿函数要定义⼀个类，相对会⽐较麻烦。使⽤ lambda 去定义可调⽤对象，既简朴⼜⽅便。
示例代码一：

1. // lambda 可以理解为定义了一个匿名函数的对象
2. int main()
3. {
4.         //lambda表达式没有类型，需要使用auto推导
5.         auto add1 = [](int x, int y)->int {return x + y; };
6.         cout << add1(1, 2) << endl;
8.         //多行时可以这样写
9.         auto func1 = []()->int
10.         {
11.                 cout << "hello bit" << endl;
12.                 cout << "hello world" << endl;
13.                 return 0;
14.         };
16.         func1();
18.         // 返回值类型可自动推导类型，所以可以省略
19.         auto func2 = []
20.         {
21.                 cout << "hello bit" << endl;
22.                 cout << "hello world" << endl;
23.                 return 0;
24.         };
26.         cout << func2() << endl;
28.         //无形参是也可以省略
29.         auto func3 = []
30.         {
31.                 cout << "hello bit" << endl;
32.                 cout << "hello world" << endl;
33.         };
35.         func3();
37.         return 0;
38. }

复制代码

示例代码二：

1. int main()
2. {
3.         int a = 0, b = 1;
5.         auto swap1 = [](int& x, int& y)
6.         {
7.                 // 只能用当前lambda局部域(即形参)和捕捉的对象(捕获列表)
8.                 int tmp = x;
9.                 x = y;
10.                 y = tmp;
11.         };
13.         swap1(a, b);
15.         // 传值捕捉本质是一种拷贝,并且const修饰了
16.         // mutable相当于去掉const属性，可以修改了
17.         // 但是修改了不会影响外面被捕捉的值，因为是一种拷贝
18.         auto swap2 = [a, b]()mutable
19.         {
20.                 int tmp = a;
21.                 a = b;
22.                 b = tmp;
23.         };
25.         swap2();
27.         //如果想在lambda表达式中影响外部的值，可以传引用捕获
28.         //传引用捕获的值不会被const修饰，在表达式内可以直接修改
29.         auto swap3 = [&a, &b]()
30.         {
31.                 int tmp = a;
32.                 a = b;
33.                 b = tmp;
34.         };
36.         swap3();
38.         return 0;
39. }

复制代码

示例代码三：

1. int x = 0;
3. int main()
4. {
5.         // 只能用当前lambda局部域和捕捉的对象
6.         // 全局对象和静态变量不需要捕获，直接就可以使用
7.         int a = 0, b = 1, c = 2, d = 3;
8.         // 所有值传值捕捉
9.         auto func1 = [=]
10.         {
11.                 int ret = a + b + c + d + x;
12.                 return ret;
13.         };
14.        
15.         // 所有值传引用捕捉
16.         auto func2 = [&]
17.         {
18.                 a++;
19.                 b++;
20.                 c++;
21.                 d++;
22.                 int ret = a + b + c + d;
23.                 return ret;
24.         };
26.         // 混合捕捉
27.         auto func3 = [&a, b]
28.         {
29.                 a++;
30.                 // b++;
31.                 int ret = a + b;
32.                 return ret;
33.         };
35.         // 混合捕捉
36.         // 所有值以引用方式捕捉，d用传值捕捉
37.         auto func4 = [&, d]
38.         {
39.                 a++;
40.                 b++;
41.                 c++;
42.                 //d++;
44.                 int ret = a + b + c + d;
45.         };
47.         //所有值以传值方式捕获，d传引用捕获
48.         auto func5 = [=, &d]() mutable
49.         {
50.                 a++;
51.                 b++;
52.                 c++;
53.                 d++;
54.                 int ret = a + b + c + d;
55.         };
57.         return 0;
58. }

复制代码

  lambda 在许多其他地⽅⽤起来也很好⽤。⽐如线程中定义线程的执⾏函数逻辑，智能指针中定制删除器等， lambda 的应⽤还是很⼴泛的，以后我们会不停接触到。
  6.4、lambda的原理

lambda 的原理和范围for很像，编译后从汇编指令层的⻆度看，压根就没有 lambda 和范围for 这样的东西。范围for底层是迭代器，⽽lambda底层是仿函数对象，也就说我们写了⼀个lambda 以后，编译器会⽣成⼀个对应的仿函数的类。
仿函数的类名是编译按⼀定规则⽣成的，保证差别的 lambda ⽣成的类名差别，lambda参数/返回类型/函数体就是仿函数operator()的参数/返回类型/函数体， lambda 的捕捉列表本质是⽣成的仿函数类的成员变量，也就是说捕捉列表的变量都是 lambda 类构造函数的实参，当然隐式捕捉，编译器要看使⽤哪些就传那些对象。
七、包装器

7.1、function

• std::function 是⼀个类模板，也是⼀个包装器。 std::function 的实例对象可以包装，存储其他的可调⽤对象，包括函数指针、仿函数、 lambda 、 bind 表达式等，存储的可调⽤对象被称为std::function 的⽬标。若 std::function 不含⽬标，则称它为空。调⽤空 std::function 的⽬标导致抛出 std::bad_function_call 异常。
  
•  function的官⽅⽂件链接:function - C++ Reference
  

下面是 function 的原型，他被定义<functional>头⽂件中：

函数指针、仿函数、 lambda 等可调⽤对象的类型各不相同， std::function 的优势就是统⼀类型，对他们都可以进⾏包装，这样在许多地⽅就⽅便声明可调⽤对象的类型。
   语法： function<返回值类型(形参类型)> 变量名 = 封装的可调用对象
  示例代码：

1. #include<functional>
3. int f(int a, int b)
4. {
5.         return a + b;
6. }
8. struct Functor
9. {
10. public:
11.         int operator() (int a, int b)
12.         {
13.                 return a + b;
14.         }
15. };
17. class Plus
18. {
19. public:
20.         static int plusi(int a, int b)
21.         {
22.                 return a + b;
23.         }
25.         double plusd(double a, double b)
26.         {
27.                 return a + b;
28.         }
29. };
31. int main()
32. {
33.         // 包装可调用对象
34.         //函数
35.         function<int(int, int)> f1 = f;
36.         //仿函数
37.         function<int(int, int)> f2 = Functor();
38.         //lambda表达式
39.         function<int(int, int)> f3 = [](int a, int b) {return a + b; };
41.         cout << f1(1, 1) << endl;
42.         cout << f2(1, 1) << endl;
43.         cout << f3(1, 1) << endl;
45.         // 包装静态成员函数
46.         //静态成员函数不用取地址符也可以取到地址，所以这里不写&也可以
47.         function<int(int, int)> f4 = &Plus::plusi;
48.         cout << f4(1, 1) << endl;
50.         // 包装非静态成员函数
51.         //类的非静态成员函数必须有取地址符才能取到地址
52.         //因为非静态成员函数有隐含的this指针，所以需要多传一个参数
53.         //这个参数可以是类类型的指针，也可以是类对象
54.         //指针版
55.         function<double(Plus*, double, double)> f5 = &Plus::plusd;
56.         Plus pd;
57.         cout << f5(&pd, 1.1, 1.1) << endl;
59.         // 类对象版
60.         function<double(Plus, double, double)> f6 = &Plus::plusd;
61.         cout << f6(pd, 1.1, 1.1) << endl;
62.         cout << f6(Plus(), 1.1, 1.1) << endl;
64.         return 0;
65. }

复制代码

下⾯的代码样例展⽰了 std::function 作为map的参数，实现字符串和可调⽤对象的映射表功能。

1. // 这种⽅式的最⼤优势之⼀是⽅便扩展，假设还有其他运算，我们增加map中的映射即可
2. class Solution
3. {
4. public:
5.         int evalRPN(vector<string>& tokens)
6.         {
7.                 stack<int> st;
8.                 // function作为map的映射可调⽤对象的类型
9.                 map<string, function<int(int, int)>> opFuncMap =
10.                 {
11.                         {"+", [](int x, int y) {return x + y; }},
12.                         {"-", [](int x, int y) {return x - y; }},
13.                         {"*", [](int x, int y) {return x * y; }},
14.                         {"/", [](int x, int y) {return x / y; }}
15.                 };
16.                 for (auto& str : tokens)
17.                 {
18.                         if (opFuncMap.count(str)) // 操作符
19.                         {
20.                                 int right = st.top();
21.                                 st.pop();
22.                                 int left = st.top();
23.                                 st.pop();
25.                                 int ret = opFuncMap[str](left, right);
26.                                 st.push(ret);
27.                         }
28.                         else
30.                         {
31.                                 st.push(stoi(str));
32.                         }
33.                 }
34.                 return st.top();
35.         }
36. };

复制代码

7.2、bind

• bind 是⼀个函数模板，它也是⼀个可调⽤对象的包装器，可以把他看做⼀个函数适配器，对吸收的fn可调⽤对象进⾏处理后返回⼀个可调⽤对象。 bind 可以⽤来调整参数个数和参数次序。
  
• bind 也在<functional>这个头⽂件中。
  
• 调⽤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/_2/_3....这些占位符放到placeholders的⼀个命名空间中。
  

bind声明：

​​​​​​​placeholders声明：

示例代码：

1. //这里它们从命名空间中放开
2. //否则指定命名空间的方式写起来太长了
3. using placeholders::_1;
4. using placeholders::_2;
5. using placeholders::_3;
7. int Sub(int a, int b)
8. {
9.         return (a - b) * 10;
10. }
12. int SubX(int a, int b, int c)
13. {
14.         return (a - b - c) * 10;
15. }
17. int main()
18. {
19.         auto sub1 = bind(Sub, _1, _2);
20.         cout << sub1(10, 5) << endl;
22.         // bind 本质返回的一个仿函数对象
23.         // 调整参数顺序（不常用）
24.         // _1代表第一个实参
25.         // _2代表第二个实参
26.         // ...以此类推
27.         auto sub2 = bind(Sub, _2, _1);
28.         cout << sub2(10, 5) << endl;
30.         // 调整参数个数 （常用）
31.         //直接将第一个参数固定了
32.         auto sub3 = bind(Sub, 100, _1);
33.         cout << sub3(5) << endl;
35.         auto sub4 = bind(Sub, _1, 100);
36.         cout << sub4(5) << endl;
38.         // 分别绑死第123个参数
39.         auto sub5 = bind(SubX, 100, _1, _2);
40.         cout << sub5(5, 1) << endl;
42.         auto sub6 = bind(SubX, _1, 100, _2);
43.         cout << sub6(5, 1) << endl;
45.         auto sub7 = bind(SubX, _1, _2, 100);
46.         cout << sub7(5, 1) << endl;
48.         function<double(Plus, double, double)> f6 = &Plus::plusd;
49.         Plus pd;
50.         cout << f6(pd, 1.1, 1.1) << endl;
51.         cout << f6(Plus(), 1.1, 1.1) << endl;
53.         // bind一般用于，绑死一些固定参数
54.         function<double(double, double)> f7 = bind(&Plus::plusd, Plus(), _1, _2);
55.         cout << f7(1.1, 1.1) << endl;
57.         //auto func1 = [](double rate, double monty, int year)->double {return monty * rate * year;};
58.         auto func1 = [](double rate, double monty, int year)->double {
59.                 double ret = monty;
60.                 for (int i = 0; i < year; i++)
61.                 {
62.                         ret += ret * rate;
63.                 }
65.                 return ret - monty;
66.                 };
68.         function<double(double)> func3_1_5 = bind(func1, 0.015, _1, 3);
69.         function<double(double)> func5_1_5 = bind(func1, 0.015, _1, 5);
70.         function<double(double)> func10_2_5 = bind(func1, 0.025, _1, 10);
71.         function<double(double)> func20_3_5 = bind(func1, 0.035, _1, 30);
73.         cout << func3_1_5(1000000) << endl;
74.         cout << func5_1_5(1000000) << endl;
75.         cout << func10_2_5(1000000) << endl;
76.         cout << func20_3_5(1000000) << endl;
78.         return 0;
79. }

复制代码

图解：

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。