C++进阶——C++11（lambda表达式）

一、lambda表达式

1、为什么要用 lambda 表达式

当我们要用 sort 来排序时，不可避免地要写比较器，因此我们每变一次比较规则就要重新一个仿函数。而这样就会让程序看起来非常的冗余。对于这种情况，我们可以用 lambda 表达式。

2、什么是 lambda 表达式

lambda 表达式的语法是这样的：[capture-list] (parameters) mutable -> return-type { statement }。
而且，lambda 表达式听起来是一个表达式而已，但其实是一个函数对象，而且其类型超级复杂，因此我们可以用 auto 来初始化 lambda 表达式。

（1）capture-list（捕捉列表）

因为有时候函数体里面会用到除参数列表的参数以外所在栈帧的其他变量或其他的 lambda 表达式，因此就可以通过捕捉列表对除参数列表以外的变量或 lambda 表达式进行声明，这样在 lambda 表达式的函数体里才可以使用那些参数列表以外的参数。不过如果你不想使用捕捉列表来增加新的参数，其实也可以加在捕捉列表里的参数加到参数列表里就行了，但外来函数还是只能通过捕捉列表去声明。

[ &var ]：引用捕捉该变量(传变量的别名，可能会改变该变量)；[ = ]：全部外来变量传值捕捉（传变量的拷贝，不会改变该变量);  [ var ]：传值捕捉该变量或捕捉其他函数对象（lambda 表达式）

auto add = [](int a, int c)->int{ return a + c; };
auto func2 = [add, =, &b](int c)->int{ add(a, c); return b += a + c; };
// 这里 b 是引用捕捉，因此函数体内的 b += a + c 会改变函数体外的 b
// 但 a 是传值捕捉，因此函数体内无论 a 如何变化，都不会改变函数体外的 a 

（2）mutable 

通过捕捉列表传值捕捉的变量都是 const 类型的，但如果你想让它在函数体里是可变的，那可以加上 mutable，让这些传值捕捉到的变量的 const 属性都去掉。

这里推荐一道可以夯实 lambda 表达式的 oj 题：https://leetcode.cn/problems/evaluate-reverse-polish-notation/

二、包装器

1、包装器语法

 包装器是一个模板，但是在传模板参数时括号外传返回值的类型，而括号里传参数的类型。

// f 可以理解为 int f(int a, int b);
function<int(int, int)> func1 = f; // f 是函数指针
function<int(int, int)> func2 = f; // f 是仿函数对象
function<int(int, int)> func3 = f; // f 是 lambda 对象

2、为什么要用包装器

有了包装器，我们就可以把函数指针、仿函数对象、lambda 对象统一成一个类型——function<Ret(Args)> 了。

三、绑定

1、为什么要用绑定

有时候函数的形参的顺序不太合理，于是我们可以通过绑定来改变这个函数的形参顺序。

#include <functional>
#include <iostream>
using namespace std;

int sub(int a, int b)
{
    return a - b;
}

int main()
{
    function<int(int, int)> _sub = bind(sub, placeholders::_2, placeholders::_1);
    cout << sub(3, 1) << endl; // 2
    cout << _sub(1, 3) << endl; // 2
    return 0;
}

2、绑定的语法

int sub1(int a, int b)
{
    return a - b;
}

class A
{
public:
    int sub2(int a, int b)
    {
        return a - b;
    }

    static int sub3(int a, int b)
    {
        return a - b;
    }
};

int main()
{
    // sub 不是成员函数
    function<int(int, int)> _sub1 = bind(sub1, placeholders::_2, placeholders::_1);

    // sub 为静态成员函数
    function<int(int, int)> _sub3 = bind(&A::sub3, placeholders::_2, placeholders::_1);

    // sub 为普通成员函数
    A a;
    function<int(int, int)> _sub2 = bind(&A::sub2, &a, placeholders::_2, placeholders::_1);
    
    return 0;
}