注这个是博主复习使用的专题仅适用于自己以及学习过C知识点的同学目录前言一、lambda1.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. functionfunction包装器介绍function包装器统一类型function包装器简化代码function包装器的意义2.2. bindbind包装器介绍bind包装器绑定固定参数bind包装器调整传参顺序bind包装器的意义前言注这个是博主复习使用的专题仅适用于自己以及学习过C知识点的同学。一、lambda1.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 函数进行来进行。#includevector 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() { vectorGoods 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() { vectorGoods v { { 苹果, 2.1, 300 }, { 香蕉, 3.3, 100 }, { 橙子, 2.2, 1000 }, { 菠萝, 1.5, 1 } }; sort(v.begin(), v.end(), [](const Goods o1,const Goodso2) { 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,inty) { 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 worldint 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 123 x 1; //重置 func2(); cout x endl; // 5 23 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. functionfunction包装器介绍function是一种函数包装器也叫做适配器。它可以对可调用对象进行包装C中的function本质就是一个类模版。function类模板的原型如下template class T class function; // undefined template class Ret, class... Args class functionRet(Args...);模板参数说明Ret: 被包装的可调用对象的返回值类型。Args: 被包装的可调用对象的形参类型。包装示例#includefunctional 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. 包装函数指针 (函数名) functionint(int, int) f1 Add; cout f1(1, 2) endl; // 2. 包装仿函数 (函数对象) functionint(int, int)f2 Functor(); cout f2(1, 2) endl; // 3. 包装 lambda 表达式 functionint(int, int)f3 [](int a, int b) {return a b; }; cout f3(10, 20) endl; // 4. 类的静态成员函数 //functionint(int, int)f4 Plus::plusi; // correct functionint(int, int)f4 Plus::plusi; // 也可以不使用 cout f4(3, 4) endl; // 5. 类的非静态成员函数 //functiondouble(double, double)f5 Plus::plusd; // error functiondouble(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函数。代码如下templateclass 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() { //函数名 functiondouble(double) func1 f; cout useF(func1, 11.11) endl; //函数对象 functiondouble(double) func2 Functor(); cout useF(func2, 11.11) endl; //lambda表达式 functiondouble(double) func3 [](double d) {return d / 4; }; cout useF(func3, 11.11) endl; return 0; }这时三次调用useF函数所打印count的地址就是相同的并且count在三次调用后会被累加到3表示这一个useF函数被调用了三次.function包装器简化代码求解逆波兰表达式的步骤如下定义一个栈依次遍历所给字符串。如果遍历到的字符串是数字则直接入栈。如果遍历到的字符串是加减乘除运算符则从栈定抛出两个数字进行对应的运算并将运算后得到的结果压入栈中。所给字符串遍历完毕后栈顶的数字就是逆波兰表达式的计算结果。代码如下#includestack #includestring class Solution { public: int evalRPN(vectorstring tokens) { stackint 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语句。这种情况可以用包装器来简化代码。建立各个运算符与其对应需要执行的函数之间的映射关系当需要执行某一运算时就可以直接通过运算符找到对应的函数进行执行。当运算类型增加时就只需要建立新增运算符与其对应函数之间的映射关系即可。#includeunordered_map class Solution { public: int evalRPN(vectorstring tokens) { stackint st; unordered_mapstring, functionint(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. bindbind包装器介绍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() { functionint(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() { functionint(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() { //绑定固定参数 functionint(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() { //调整传参顺序 functionint(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包装器的意义将一个函数的某些参数绑定为固定的值让我们在调用时可以不用传递某些参数。可以对函数参数的顺序进行灵活调整。完