C++11：lambda表达式 & 包装器

---

lambda表达式

在C++98中，如果想对一个结构体数组使用sort排序，那么我们就需要自己些仿函数。

比如以下结构体：

struct Goods
{
    string _name; // 名字
    double _price; // 价格
    int _evaluate; // 评价
    Goods(const char* str, double price, int evaluate)
        :_name(str)
        , _price(price)
        , _evaluate(evaluate)
    {}
};
1
2
3
4
5
6
7
8
9
10
11

如果我们希望以价格排序，就可以写出如下仿函数：

struct ComparePriceLess
{
    bool operator()(const Goods& gl, const Goods& gr)
    {
        return gl._price < gr._price;
    }
};

struct ComparePriceGreater
{
    bool operator()(const Goods& gl, const Goods& gr)
    {
        return gl._price > gr._price;
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

随着C++语法的发展，人们开始觉得上面的写法太复杂了，每次为了实现一个algorithm算法，都要重新去写一个类，如果每次比较的逻辑不一样，还要去实现多个类，特别是相同类的命名，这些都给编程者带来了极大的不便。因此，在C++11语法中出现了Lambda表达式

lambda语法如下：

[capture_list] (parameters) mutable -> return_type {statement}
1

这个语法看起来比较复杂，我先简单讲拆分一下各个部分：

• [capture_list]：捕捉列表
• (parameters)：参数列表
• mutable：一个关键字
• -> return_type：返回值类型
• {statement}： 函数体

比如这是一个完整的lambda表达式：

auto add = [](int a, int b)mutable -> int { return a + b; };
1

很明显的看出，以上函数就是传入两个整数，然后返回两数之和。

lambda表达式有很多种省略情况

1. muteble可以省略，改关键字的具体功能后续讲解

auto add = [](int a, int b)-> int { return a + b; };
1

2. 函数的返回值-> return_type可以省略，lambda表达式可以自己推导返回类型

auto add = [](int a, int b) { return a + b; };
1

3. 当函数没有参数时，(parameters)参数列表可以省略

auto say_hello = [] { cout << "hello world!" << endl; };
1

以上函数，就已经是一个非常简单的lambda表达式了。那么lambda表达式有什么用呢？

 lambda会返回一个仿函数对象

比如auto add = [](int a, int b) { return a + b; };，其实add就是一个仿函数对象了，我们可以直接按照调用函数的方式来调用这个仿函数：add(1, 2);。但是要注意， lambda表达式返回的仿函数对象，其类名是随机的，因此必须使用auto来接受这个仿函数对象。

现在我们再讲讲lambda表达式最前面的[]的作用，其名称为捕获列表，可以捕获父作用域中所有变量。

比如这样：

int x = 1;
int y = 2;

auto add = [x, y] {return x + y; };
1
2
3
4

以上代码中，[x, y]就是在捕获父作用域中的两个变量，那么函数体中就可以直接使用这两个变量了。如果直接通过变量名捕获，此时是传值调用，修改函数体内部的变量，不会影响父作用域的变量。

但是通过直接传值捕获的变量，自带const属性，不允许修改，比如以下代码：

int x = 1;
int y = 2;

auto add = [x, y] 
    {
        x += 5;
        y += 5;
    };
1
2
3
4
5
6
7
8

此时代码就会报错，因为x和y是通过捕获列表捕获的变量，传入的参数带有const属性，不允许修改。此时就要用到mutable了，mutable可以让被捕获的参数可以修改。

auto add = [x, y] mutable
    {
        x += 5;
        y += 5;
    };
1
2
3
4
5

但是这个写法还是错误的，如果使用了mutable，就算没有通过参数列表传参，()也不可以省略：

auto add = [x, y] () mutable
    {
        x += 5;
        y += 5;
    };
1
2
3
4
5

我们也可以以传引用的方式来捕获变量，只需要在变量名前加上&操作符：

int x = 1;
int y = 2;

auto add = [&x, &y]
    {
        x += 5;
        y += 5;
    };
1
2
3
4
5
6
7
8

此时修改函数内部的x和y，就是在修改父作用域的x和y了。这里要注意，如果使用了传引用捕获变量，就算没有mutable也可以修改参数。

另外的，lambda还提供了一次性捕获所有父作用域变量的语法，只需要在捕获列表中写=即可：

int x = 1;
int y = 2;

auto add = [=]
    {
        return x + y;
    };
1
2
3
4
5
6
7

[=]就是一次性捕获了所有父作用域变量的过程，我们可以直接在函数体内部使用父作用域的所有变量。

不过[=]是以传值的形式捕获父作用域所有变量，而[&]是以传引用的形式捕获父作用域所有变量：

int x = 1;
int y = 2;

auto add = [&]
    {
        x += 5;
        y += 5;
    };
1
2
3
4
5
6
7
8

另外的，我们还可以把传值和传引用混合使用，让部分参数传参，部分参数传引用。

[x, &y]：以传值的形式捕获x，以传引用的形式捕获y
[=, &x]：以传值的形式捕获父作用域所有变量，以传引用的形式捕获x
[&, x]：以传值的形式捕获x，以传引用的形式捕获父作用域所有变量

接下来我再次汇总一下lambda的语法：

各个部分：

• [capture_list]：捕捉列表，可以捕获父作用域的任意变量，有传参和传引用两种形式
• (parameters)：参数列表，如果没有参数可以省略
• mutable：如果以传参形式捕获参数，不可修改参数，加上该关键字后可以修改
• -> return_type：返回值类型，可以省略，lambda会自动推导
• {statement}： 函数体，不可省略

有了lambda表达式后，我们在需要仿函数的地方，就无需额外写一个仿函数的类，而是直接写一个lambda表达式，比如最开始的按照价格排序：

vector<Goods> v = { { "苹果", 2.1, 5 }, { "香蕉", 3, 4 }, { "橙子", 2.2, 3 }, { "菠萝", 1.5, 4 } };

sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2) {
    return g1._price < g2._price; });

sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2) {
    return g1._price > g2._price; });
1
2
3
4
5
6
7

因为省略了返回值，我们以比函数还简短的方式完成了仿函数的书写。

但是有一个情况，那就是模板参数中的lambda表达式。

如果我们想要给一个优先级队列priority_queue传入一个less仿函数：

priority_queue<int, vector<int>, less<int>> q;
1

其中less<int>就是我们的仿函数，但是less<int>不是仿函数实例化出的对象，而是一个仿函数类型。也就是说，模板参数中需要的不是仿函数对象，而是仿函数类型。但是lambda表达式整体返回的类型是仿函数对象，因此以下写法是错误的：

priority_queue<int, vector<int>, [](const int& i1, const int& i2) {return i1 - i2; } > q;
1

我们不能直接把lambda当作模板参数传入，此时就要使用decltype来推导原先的类型：

auto intLess = [](const int& i1, const int& i2) {return i1 - i2; };
priority_queue<int, vector<int>, decltype(intLess)> q;
1
2

---

包装器

在寄快递的时候，快递会进行一次包装，这样我们就可以统一的在上面贴上快递信息，随后以统一的形式管理所有快递。包装器也是如此，包装器可以将具有相似属性的东西包装起来成为一个整体。

function

如果一个变量f，可以按照f()的形式调用函数，那么称f是一个可调用对象

回顾一下，现在我们有那些可调用对象：

1. 函数指针，函数名（函数名的本质就是函数指针）
2. 仿函数实例化出的对象
3. lambda表达式

这三者，都可以直接加一对()进行函数调用。它们都有各自的缺点：

• 函数指针，函数名：类型复杂，不好用
• 仿函数实例化出的对象：哪怕参数返回值都相同，仿函数之间的类型也不同
• lambda表达式：类型是随机的，必须用auto接收

可以看到，这三者都有类型方面的大问题，我们也没有一种方式可以把所有参数类型和返回值类型相同的函数，统一的管理起来，让它们都变成一个类型？

包装器function就可以做到该工作，function被包含在头文件<functional>中，是一个类模板，模板原型如下：

template <class T> function;

template <class Ret, class... Args>
class function<Ret(Args...)>;
1
2
3
4

其语法为：function<返回值(参数列表)>，只要所有返回值和参数列表相同的可调用对象，经过这一层封装，都会变成相同的类型。

比如我们现在有如下三个函数：

double func(double x)
{
    return x / 2;
}

struct Functor
{
    double operator()(double x)
    {
        return x / 3;
    }
};

int main()
{
    auto lambadaFunc = [](double d) {return d / 4; };

    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

分别是func函数，Functor仿函数，以及lambda表达式lambadaFunc 。它们的返回值都是double，参数类型也是double，因此可以经过包装器包装为function<double<double>>。

如下：

function<double(double)> func1 = func;
function<double(double)> func2 = Functor();
function<double(double)> func3 = lambadaFunc;
1
2
3

此时，三者的类型就都是function<double(double)> 了。

有了这一层包装器，在需要统一管理函数时，就很方便了。比如说我现在要搞一个计算器的map，往map中输入哪一个操作符，就调用哪一个函数：

map<char, function<int(int, int)>> opFuncMap = {
    {'+', [](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; }}
};
1
2
3
4
5
6

由于+ - * /的函数都是lambda表达式，四个表达式的类型都是不可知的，map的第二个模板参数就不知道是啥了。不过我们可以通过function进行包装，把所有函数都包装成function<int(int, int)>类型，最后就可以通过map统一管理了。

我们最后就可以这样调用函数：

opFuncMap['+'](1, 2);
opFuncMap['-'](1, 2);
opFuncMap['*'](1, 2);
opFuncMap['/'](1, 2);
1
2
3
4

---

bind

bind翻译后为绑定，其可以对参数进行绑定。其主要有两个功能：改变参数顺序，给指定参数绑定固定值。

语法：
bind是一个函数模板，其接收多个参数，第一个参数为可调用对象，后续参数为该可调用对象的参数。这个参数的语法比较特别，C++11后新增一个命名空间域placeholders，其内部会存储很多变量，这些变量用于函数的传参，变量的名字为_x表示第x个参数。

比如以下代码中：

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

int main()
{
    auto f1 = bind(sub, placeholders::_2, placeholders::_1);

    f1(3, 5);

    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13

对于bind(sub, placeholders::_2, placeholders::_1);来说，sub这个参数是一个可调用对象。
placeholders::_2表示第二个参数，placeholders::_1表示第一个参数。

比如这个f1最后拿到了这个bind封装的函数，那么f1(3, 5)执行的并不是3 - 5，而是5 - 3。

这是因为我们特地把placeholders::_2写在前面，f1(3, 5)把第二个5传给了placeholders::_2，把第一个3传给了placeholders::_1。

而最后调用sub函数的时候，placeholders::_1会被传给sub的第一个参数，placeholders::_2则会传给sub的第而个参数。这样我们就完成了函数参数顺序的改变。

再比如以下代码：

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

int main()
{
    auto f2 = bind(sub, 3.14, placeholders::_1);

    f2(10);

    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13

bind(sub, 3.14, placeholders::_1)第一个参数为可调用对象sub，第二个参数是一个固定值3.14，那么如果通过f2调用该sub函数，参数a都固定为3.14。比如f2(10)就只传了一个参数，再去调用sub时，就完成3.14 - 10的操作。因此我们可以通过sub把某个参数绑定为固定值。

---