注：这个是博主复习使用的专题，仅适用于自己以及学习过C++知识点的同学

目录

前言

一、lambda

1.1. lambda概念

1.2. lambda 表达式语法

1.3. 捕获列表

1.3.1. 空捕获列表 []

1.3.2. 值捕获 [变量名]

1.3.3. 引用捕获 [&变量名]

1.3.4. 隐式值捕获 [=]

1.3.5. 隐式引用捕获 [&]

1.3.6. 混合捕获（默认+显式）

1.3.7. mutable的使用

1.4. lambda的原理

二、包装器

2.1. function

function包装器介绍

function包装器统一类型

function包装器简化代码

function包装器的意义

2.2. bind

bind包装器介绍

bind包装器绑定固定参数

bind包装器调整传参顺序

bind包装器的意义

前言

注：这个是博主复习使用的专题，仅适用于自己以及学习过C++知识点的同学。

一、lambda

1.1. lambda概念

lambda表达式是一个匿名函数，恰当使用lambda表达式可以让代码变得简洁，并且可以提高代码的可读性。

举个例子

商品类Goods的定义如下：

struct Goods { string _name; // 名字 double _price; // 价格 int _num; // 数量 Goods(const char* str,double price,int num): _name(str),_price(price),_num(num) {} };

现在要对若干商品分别按照价格和数量进行升序、降序排序。

此时使用仿函数 和 sort 函数进行来进行。

#include<vector> struct Goods { string _name; // 名字 double _price; // 价格 int _num; // 数量 Goods(const char* str,double price,int num): _name(str),_price(price),_num(num) {} }; struct ComparePriceLess { bool operator()(const Goods& o1, const Goods& o2) { return o1._price < o2._price; } }; struct ComparePriceGreater { bool operator()(const Goods& o1, const Goods& o2) { return o1._price > o2._price; } }; struct CompareNumLess { bool operator()(const Goods& o1, const Goods& o2) { return o1._num > o2._num; } }; struct CompareNumGreater { bool operator()(const Goods& o1, const Goods& o2) { return o1._num > o2._num; } }; int main() { vector<Goods> v = { { "苹果", 2.1, 300 }, { "香蕉", 3.3, 100 }, { "橙子", 2.2, 1000 }, { "菠萝", 1.5, 1 } }; sort(v.begin(), v.end(), ComparePriceLess()); sort(v.begin(), v.end(), ComparePriceGreater()); sort(v.begin(), v.end(), CompareNumLess()); sort(v.begin(), v.end(), CompareNumGreater()); return 0; }

对于这种场景就比较适合使用lambda表达式。比如：

int main() { vector<Goods> v = { { "苹果", 2.1, 300 }, { "香蕉", 3.3, 100 }, { "橙子", 2.2, 1000 }, { "菠萝", 1.5, 1 } }; sort(v.begin(), v.end(), [](const Goods& o1,const Goods&o2) { return o1._price < o2._price; }); sort(v.begin(), v.end(), [](const Goods& o1, const Goods& o2) { return o1._price > o2._price; }); sort(v.begin(), v.end(), [](const Goods& o1, const Goods& o2) { return o1._num < o2._num; }); sort(v.begin(), v.end(), [](const Goods& o1, const Goods& o2) { return o1._num > o2._num; }); return 0; }

这样一来，每次调用sort函数时只需要传入一个lambda表达式指明比较方式即可，阅读代码的人一看到lambda表达式就知道本次排序的比较方式是怎样的，提高了代码的可读性

1.2. lambda 表达式语法

lambda表达式书写格式：[capture-list](parameters)mutable->return-type{statement}

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

lambda函数的参数列表和返回值类型都是可选部分，但捕捉列表和函数体是不可省略的，因此最简单的lambda函数如下：

int main() { [] {}; // 最简单的 lambda 表达式 return 0; }

下面是几个简单的 lambda 表达式：

两个整数相加：

int main() { // 两个整数相加： auto add = [](int x, int y)->int { return x + y; }; cout << add(1, 2) << endl; return 0; }

两个整数交换：

int main() { // 两个整数交换： int a = 10, b = 20; auto swap = [](int &x,int&y) { int tmp = x; x = y; y = tmp; }; cout << "a = " << a << ",b = " << b << endl; swap(a, b); cout << "a = " << a << ",b = " << b << endl; return 0; }

打印 hello world

int main() { // 打印 hello world auto print = []() { cout << "hello world" << endl; }; print(); return 0; }

1.3. 捕获列表

lambda 表达式中默认只能用 lambda 函数体和参数中的变量，如果想用外层作用域中的变量就需要进行捕获。

1.3.1. 空捕获列表 []

表示不捕获任何外部变量，lambda 体内只能使用参数和全局变量。就和上面打印的一样。

int main() { // 打印 hello world auto print = []() { cout << "hello world" << endl; }; print(); return 0; }

1.3.2. 值捕获[变量名]

将外部变量按值复制到 lambda 内部，副本在 lambda 定义时确定，之后外部变量的改变不影响 lambda 内的副本。

int main() { int x = 5; auto func = [x] { return x + 1; }; // 捕获 x 的副本 x = 10; cout << func() << endl; // 输出 6 cout << x << endl; // 10 修改外部变量不影响 lambda 内的副本 return 0; }

1.3.3. 引用捕获[&变量名]

以引用方式捕获外部变量，lambda 体内使用的是原变量的引用，因此可以修改外部变量，且外部变量的变化会影响 lambda 内的访问。

int main() { int x = 5; auto func = [&x] { x += 1; return x ; }; cout << func() << endl; // 6 cout << x << endl; // 6 return 0; }

1.3.4. 隐式值捕获[=]

按值捕获所有在 lambda 体中使用的自动变量（即局部变量）。编译器自动推导需要哪些变量，并复制它们。

int main() { int a = 1, b = 2; auto func = [=] { return a + b; }; // 捕获 a 和 b 的副本 a = 10; b = 20; // 不影响 lambda 内的副本 cout << func() << endl; // 输出 3 cout << a << '\t' << b << endl; return 0; }

1.3.5. 隐式引用捕获[&]

按引用捕获所有在 lambda 体中使用的自动变量。通过引用操作原变量。

int main() { int a = 1, b = 2; auto func = [&] { a += b; return a; }; // 捕获 a, b 的引用 cout << func()<< endl; // 输出 3 cout << a << endl;// 输出 3 (被修改) return 0; }

1.3.6. 混合捕获（默认+显式）

可以组合使用隐式和显式捕获，但要遵循规则：

• [=, &x]：默认按值捕获，但 x 按引用捕获。

• [&, x]：默认按引用捕获，但 x 按值捕获。

• 注意：不能重复捕获同一个变量。

int main() { int x = 1, y = 2, z = 3; auto func = [=, &x] { x += y + z; // y z 值捕获，x 引用捕获 }; auto func2 = [&, y] { x = y + z; // x z 引用捕捉，y 值捕捉 }; func(); cout << x << endl; // 6 1+2+3 x = 1; //重置 func2(); cout << x << endl; // 5 2+3 return 0; }

1.3.7. mutable的使用

在 C++ 的 lambda 表达式中，mutable是一个修饰符，用于允许修改通过值捕获的变量。默认情况下，lambda 的operator()是const限定的，这意味着在 lambda 体内，所有值捕获的变量都是只读的（相当于 const 副本）。加上mutable后，operator()变为非const，从而可以修改这些值副本。

值捕获与引用捕获的修改

int main() { int a = 1, b = 1; // 值捕获 + mutable：修改副本 auto func = [a]() mutable { a += 1; // 默认是 a 被 const，使用 mutable 就没有 const 限制 return a; }; // 引用捕获：修改原变量 auto func2 = [&b]() { b += 1; return b; }; cout << "func: " << func() << endl; // 2 cout << "func: " << func() << endl; // 3 cout << "a: " << a << endl; // 1（不变） cout << "func2: " << func2() << endl; // 2 cout << "func2: " << func2() << endl; // 3 cout << "b: " << b << endl; // 3（被修改） return 0; }

1.4. lambda的原理

lambda的原理和范围for很像，编译后从汇编指令层的角度看，压根没有 lambda 和 范围 for。范围for底层是迭代器，而 lambda 底层是仿函数，相当于说，写一个 lambda对象，编译器会生成一个对应的仿函数的类。

仿函数的类名是编译按一定规则生成的，保证不同的 lambda 生成的类名不同：

• lambda 参数/返回类型/函数体就是仿函数 operator() 的参数/返回类型/函数体。
• lambda 的捕捉列表本质：生成的仿函数类的成员变量，也就是说捕捉列表的变量都是 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; // lambda auto r2 = [rate](double money, int year) { return money * rate * year; }; // 函数对象 Rate r1(rate); r1(10000, 2); r2(10000, 2); return 0; }

二、包装器

2.1. function

function包装器介绍

function是一种函数包装器，也叫做适配器。它可以对可调用对象进行包装，C++中的function本质就是一个类模版。

function类模板的原型如下：

template <class T> class function; // undefined template <class Ret, class... Args> class function<Ret(Args...)>;

模板参数说明：

• Ret: 被包装的可调用对象的返回值类型。
• Args: 被包装的可调用对象的形参类型。

包装示例

#include<functional> int Add(int a, int b) { return a + b; } struct Functor { 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() { // 1. 包装函数指针 (函数名) function<int(int, int)> f1 = Add; cout << f1(1, 2) << endl; // 2. 包装仿函数 (函数对象) function<int(int, int)>f2 = Functor(); cout << f2(1, 2) << endl; // 3. 包装 lambda 表达式 function<int(int, int)>f3 = [](int a, int b) {return a + b; }; cout << f3(10, 20) << endl; // 4. 类的静态成员函数 //function<int(int, int)>f4 = &Plus::plusi; // correct function<int(int, int)>f4 = Plus::plusi; // 也可以不使用& cout << f4(3, 4) << endl; // 5. 类的非静态成员函数 //function<double(double, double)>f5 = &Plus::plusd; // error function<double(Plus,double, double)>f5 = &Plus::plusd; // 非静态成员函数参数中第一个是this指针 cout << f5(Plus(), 2.2, 8.8) << endl; return 0; }

注意事项：

• 包装时指明返回值类型和各形参类型，然后将可调用对象赋值给function包装器即可，包装后function对象就可以像普通函数一样使用了。
• 取静态成员函数的地址可以不用取地址运算符“&”，但取非静态成员函数的地址必须使用取地址运算符“&”。
• 包装非静态的成员函数时需要注意，非静态成员函数的第一个参数是隐藏this指针，因此在包装时需要指明第一个形参的类型为类的类型

function包装器统一类型

对于以下函数模板useF：

• 传入该函数模板的第一个参数可以是任意的可调用对象，比如函数指针、仿函数、lambda表达式等。
• useF中定义了静态变量count，并在每次调用时将count的值和地址进行了打印，可判断多次调用时调用的是否是同一个useF函数。

代码如下：

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; //lambda表达式 cout << useF([](double d) {return d / 4; } , 11.11) << endl; return 0; }

由于函数指针、仿函数、lambda表达式是不同的类型，因此useF函数会被实例化出三份，三次调用useF函数所打印count的地址也是不同的。

• 但实际这里根本没有必要实例化出三份useF函数，因为三次调用useF函数时传入的可调用对象虽然是不同类型的，但这三个可调用对象的返回值和形参类型都是相同的。
• 这时就可以用包装器分别对着三个可调用对象进行包装，然后再用这三个包装后的可调用对象来调用useF函数，这时就只会实例化出一份useF函数。
• 根本原因就是因为包装后，这三个可调用对象都是相同的function类型，因此最终只会实例化出一份useF函数，该函数的第一个模板参数的类型就是function类型的。
  

int main() { //函数名 function<double(double)> func1 = f; cout << useF(func1, 11.11) << endl; //函数对象 function<double(double)> func2 = Functor(); cout << useF(func2, 11.11) << endl; //lambda表达式 function<double(double)> func3 = [](double d) {return d / 4; }; cout << useF(func3, 11.11) << endl; return 0; }

这时三次调用useF函数所打印count的地址就是相同的，并且count在三次调用后会被累加到3，表示这一个useF函数被调用了三次.

function包装器简化代码

求解逆波兰表达式的步骤如下：

• 定义一个栈，依次遍历所给字符串。
• 如果遍历到的字符串是数字则直接入栈。
• 如果遍历到的字符串是加减乘除运算符，则从栈定抛出两个数字进行对应的运算，并将运算后得到的结果压入栈中。
• 所给字符串遍历完毕后，栈顶的数字就是逆波兰表达式的计算结果。

代码如下：

#include<stack> #include<string> class Solution { public: int evalRPN(vector<string>& tokens) { stack<int> st; for (const auto& str : tokens) { int left, right; if (str == "+" || str == "-" || str == "*" || str == "/") { right = st.top(); st.pop(); 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; default: break; } } else { st.push(stoi(str)); } } return st.top(); } };

在上述代码中，我们通过switch语句来判断本次需要进行哪种运算，如果运算类型增加了，比如增加了求余、幂、对数等运算，那么就需要在switch语句的后面中继续增加case语句。

这种情况可以用包装器来简化代码。

• 建立各个运算符与其对应需要执行的函数之间的映射关系，当需要执行某一运算时就可以直接通过运算符找到对应的函数进行执行。
• 当运算类型增加时，就只需要建立新增运算符与其对应函数之间的映射关系即可。

#include<unordered_map> class Solution { public: int evalRPN(vector<string>& tokens) { stack<int> st; unordered_map<string, function<int(int, int)>>oper = { {"+",[](int x,int y) {return x + y; }}, {"-",[](int x,int y) {return x - y; }}, {"*",[](int x,int y) {return x * y; }}, {"/",[](int x,int y) {return x / y; }} }; for (const auto& str : tokens) { int left, right; if (str == "+" || str == "-" || str == "*" || str == "/") { right = st.top(); st.pop(); left = st.top(); st.pop(); st.push(oper[str](left, right)); } else { st.push(stoi(str)); } } return st.top(); } };

需要注意的是，这里建立的是运算符与function类型之间的映射关系，因此无论是函数指针、仿函数还是lambda表达式都可以在包装后与对应的运算符进行绑定。

function包装器的意义

• 将可调用对象的类型进行统一，便于我们对其进行统一化管理。
• 包装后明确了可调用对象的返回值和形参类型，更加方便使用者使用。

2.2. bind

bind包装器介绍

bind包装器介绍

bind也是一种函数包装器，也叫做适配器。它可以接受一个可调用对象，生成一个新的可调用对象来“适应”原对象的参数列表，C++中的bind本质是一个函数模板。

bind函数模板的原型如下：

simple(1) 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);

模板参数说明：

• fn: 可调用对象。
• args: 要绑定的参数列表：值或占位符。

调用bind的一般形式

调用bind的一般形式为：auto newCallable = bind(callable, arg_list);

解释说明：

• callable：需要包装的可调用对象。
• newCallable：生成的新的可调用对象.
• arg_list：逗号分隔的参数列表，对应给定的callable的参数。当调用newCallable时，newCallable会调用callable，并传给它arg_list中的参数。
• arg_list中的参数可能包含形如_n的名字，其中n是一个整数，这些参数是“占位符”，表示newCallable的参数，它们占据了传递给newCallable的参数的“位置”。数值n表示生成的可调用对象中参数的位置，比如_1为newCallable的第一个参数，_2为第二个参数，以此类推。

此外，除了用auto接收包装后的可调用对象，也可以用function类型指明返回值和形参类型后接收包装后的可调用对象。

bind包装器绑定固定参数

无意义绑定

下面的就是无意义绑定：

int Add(int a,int b) { return a + b; } int main() { function<int(int, int)> f = bind(Add,std::placeholders::_1,std::placeholders::_2); cout << f(1, 2) << endl; return 0; }

绑定时第一个参数传入函数指针这个可调用对象，但后续传入的要绑定的参数列表依次是std::placeholders::_1和std::placeholders::_2，表示后续调用新生成的可调用对象时，传入的第一个参数传给std::placeholders::_1，传入的第二个参数传给std::placeholders::_2。此时绑定后生成的新的可调用对象的传参方式，和原来没有绑定的可调用对象是一样的，所以说这是一个无意义的绑定。

绑定固定参数

如果想把Add函数的第二个参数固定绑定为10，可以在绑定时将参数列表的placeholders::_2设置为10。比如：

int Add(int a,int b) { return a + b; } int main() { function<int(int)> func = bind(Add, placeholders::_1, 10); cout << func(2) << endl; //12 return 0; }

此时调用绑定后新生成的可调用对象时就只需要传入一个参数，它会将该值与10相加后的结果进行返回。

bind包装器调整传参顺序

调整传参顺序

对于下面Sub类中的sub成员函数，sub成员函数的第一个参数是隐藏的this指针，如果想要在调用sub成员函数时不用对象进行调用，那么可以将sub成员函数的第一个参数固定绑定为一个Sub对象。比如：

class Sub { public: int sub(int a, int b) { return a - b; } }; int main() { //绑定固定参数 function<int(int, int)> func = bind(&Sub::sub, Sub(), placeholders::_1, placeholders::_2); cout << func(1, 2) << endl; //-1 return 0; }

此时调用绑定后生成的可调用对象时，就只需要传入用于相减的两个参数了，因为在调用时会固定帮我们传入一个匿名对象给this指针。

如果想要将sub成员函数用于相减的两个参数的顺序交换，那么直接在绑定时将placeholders::_1和placeholders::_2的位置交换一下就行了。比如：

class Sub { public: int sub(int a, int b) { return a - b; } }; int main() { //调整传参顺序 function<int(int, int)> func = bind(&Sub::sub, Sub(), std::placeholders::_2, std::placeholders::_1); cout << func(1, 2) << endl; //1 return 0; }

根本原因就是因为，后续调用新生成的可调用对象时，传入的第一个参数会传给placeholders::_1，传入的第二个参数会传给placeholders::_2，因此可以在绑定时通过控制placeholders::_n的位置，来控制第n个参数的传递位置。

bind包装器的意义

• 将一个函数的某些参数绑定为固定的值，让我们在调用时可以不用传递某些参数。
• 可以对函数参数的顺序进行灵活调整。

完