c++ lambda表达式与函数对象

1.lambda表达式语法

c++11以后引入了lambda表达式。lambda表达式还是很好用的一个东东，谁用谁知道。对比java，java8中也引入了lambda表达式，好评如潮，确实在很多场景中能发挥很大的作用。下面我们就来看看lambda表达式的使用。

lambda表达式的完整声明语法如下

[capture list] (params list) mutable exception-> return type { function body }

capture list: 表示捕获的外部变量
params list: 形参列表
mutable指示符: 是否可以修改捕获的变量
exception: 异常设置
return type: 返回类型
function body: 函数体实现

实际使用中，大部分时候都不会使用上述完整的声明。

[capture list] (params list) -> return type { function body }
[capture list] (params list) { function body }
[capture list] { function body }

上面第一种声明方式，表示该表达式不能修改捕获列表中的值。
第二种声明方式，则直接省略了返回类型，返回类型从函数体中可以推断。如果函数体中存在return语句，则返回类型为return语句的返回类型；如果没有return语句，则返回的是void类型。
第三种声明方式，省略了参数列表，表示是一个无参函数。

2.lambda表达式实例

上面说了很多理论，下面我们来看看lambda表达式的实操。

以库函数qsort为例

int cmp(const void *a,const void *b){
    return *(int *)a-*(int *)b;
}
void use_qsort() {
    int arr[] = {1, 3, 5, 2, 4, 6, 0, 9, 7, 8};
    qsort(arr, 10, sizeof(int), cmp);
    for(int i=0; i<10; i++) {
        cout<<arr[i]<<" ";
    }
}

在有lambda表达式之前，我们可以按上面方法这么做，先定义一个cmp函数，再传到qsort里面。其中(int *)a表示将void指针a转化成int类型指针，再用*操作符提取a的具体指。

上面比较麻烦的地方在于还需要定义一个函数，光一想到要给这个函数取名就头疼。如果这个函数是一次性的，在其他地方没有使用，完全可以使用lambda表达式代替

void use_qsort() {
    int arr[] = {1, 3, 5, 2, 4, 6, 0, 9, 7, 8};
    qsort(arr, 10, sizeof(int), [](const void *a,const void *b) -> int {return *(int *)a-*(int *)b;});
    for(int i=0; i<10; i++) {
        cout<<arr[i]<<" ";
    }
}

当然我们按照第一部分介绍的语法，也可以将返回类型去掉，编译器可以根据return语句自己推断出返回类型。

void use_qsort() {
    int arr[] = {1, 3, 5, 2, 4, 6, 0, 9, 7, 8};
    qsort(arr, 10, sizeof(int), [](const void *a,const void *b) {return *(int *)a-*(int *)b;});
    for(int i=0; i<10; i++) {
        cout<<arr[i]<<" ";
    }
}

这样也是可以的

3.捕获列表

如果捕获的变量数量比较多，捕获列表会相当冗长并且容易出错。针对这种情况, c++提供了隐式捕获的符号，它代表着没有显式捕获的所有变量的默认行为。
[] 表示空捕获，没有捕获任何变量
[names] 一个逗号分隔的捕获变量列表
[&] 引用捕获所有外部变量，注意引用捕获是针对地址，所以可以修改变量并输出。
[=] 值捕获，即使修改变量无法输出
[&, identifier_list] 除identifier_list以外其他变量引用捕获
[=, identifier_list] 除identifier_list以外其他变量值捕获

4.函数对象

重载函数调用操作符的类，其对象通常被称为函数对象(function object)，或者叫仿函数(functor)。对外表现出来的特性是对象与函数类似可以用()直接调用，底层实质则是代码重载了()操作符。

注意函数对象(仿函数)是一个类对象，而不是函数。

相比于普通函数，函数对象的优点主要在两点：
1.函数对象可以有自己的状态。我们可以在类中定义状态变量，这样一个函数对象在多次的调用中可以共享这个状态。但是函数调用没这种优势，除非它使用全局变量来保存状态。
2.函数对象可以有自己的类型，普通函数没有。在标准库中有大量的泛型模板，函数对象可以方便我们使用。

看一个具体的例子

class MyClass {
    public:
        int num=0;
        MyClass() {}
        void operator() (int n) {
            cout<<n<<endl;
            num++;
        }
};

void f2() {
    MyClass MyClass;
    MyClass(10);
    MyClass(20);
    MyClass(30);
    cout<<MyClass.num<<endl;
}

代码运行以后结果为

10
20
30
3