[C++] C++11新特性之lambda表达式（匿名函数）、bind函数（函数适配器）、function模板类型（可调用对象包装器）

什么是lambda表达式？

一个lambda表达式可以理解为是一个一个未命名的内联函数，也就是可调用的代码单元，即可调用对象。lambda表达式定义立即执行，无需跳出当前函数，可以简化代码，可以把多行代码简化成一行。

• 可调用对象有四种：

  • 函数
  • 函数指针
  • 重载了函数调用运算符的类
  • lambda表达式
  • bind创建的对象

• 与任何函数类似，一个lambda表达式具有：一个返回类型、一个参数列表、一个函数体。与函数不同的是，lambda表达式可定义在函数的内部。

  lambda表达式的形式

  [捕获列表] (参数列表) -> 返回类型 {函数体};
  

  • 捕获列表：是一个lambda所在函数中定义的局部变量的列表（通常为空）
  • 返回类型、参数列表、函数体与任何普通函数一样
  • 与普通函数不同的是，lambda必须使用尾置返回来指定返回类型，即-> 返回类型

• 参数列表和返回类型可以忽略，必须保证捕获列表和函数体

  //可调用对象fun，不接受参数，返回12
  auto fun = [] {return 12;};
  
  //lambda表达式的调用方式
  std::cout << fun() << std::endl;
  

  如果函数体只是一个return语句，则返回类型从返回的表达式的类型推断出来，否则返回类型为void。

  即，如果lambda表达式的函数体包含任何单一return语句之外的内容，且未指定返回类型，则返回void。

向lambda表达式传递参数

调用一个lambda表达式时给定的实参用来初始化lambda表达式的形参。

lambda表达式不能有默认参数，lambda表达式的形参和实参数目相等，调用的时候写入参数。

//空捕获列表表示lambda表达式不使用它所在函数中的任何局部变量
[] (const string &str1, const string &str2) {return str1.size() > str2.size();};

lambda表达式的捕获列表

一个lambda表达式通过将局部变量包含在其捕获列表中来指出将会使用这些变量。

//由于lambda表达式捕获size，因此lambda表达式的函数体可以使用size
[size] (const string &str) {return str.size() >= size;};

一个lambda表达式只有其捕获列表中捕获一个它所在函数中的局部变量，才能在函数体中使用该变量。

类似参数传递，变量的捕获方式也可以是值或者引用。

[]	空捕获列表，不能使用所在函数中的变量
[a]	a是一个逗号分隔的名字列表，这些名字都是lambda所在函数的局部变量，分为值捕获、引用捕获
[&]	隐式捕获列表，采用引用捕获方式，所有局部变量都采用引用捕获
[=]	隐式捕获列表，采用值捕获方式，所有局部变量都采用值捕获
[&, a]	a是一个逗号分隔符列表，这些变量采用值捕获方式，而隐式捕获的局部变量都采用引用捕获方式
[=, a]	a是一个逗号分隔符列表，这些变量采用引用捕获方式，而隐式捕获的局部变量都采用值捕获方式
[this]	通过引用捕获当前对象（其实是复制指针）
[*this]	通过传值方式捕获当前对象

• 值捕获

  • 与传值参数类似，采用值捕获的前提是变量可拷贝

  • 与传值参数不同，被捕获的局部变量的值是在lambda表达式创建时拷贝，而不是调用时拷贝

  • void fun1() {
        size_t a = 12;//局部变量
        //将局部变量a拷贝到名为f的可调用对象
        auto lmd = [a] {return a;};
        a = 0;
        auto k = lmd();//k为12，lmd保存了我们创建它时a的拷贝
    }
    

    由于被捕获变量的值是在lambda创建时拷贝，因此随后对其的修改不会影响到lambda内对应的值

• 引用捕获

  • 引用捕获的变量与其他任何类型的引用的行为类似

  • 如果采用引用方式捕获一个变量，就必须保证被引用对象在lambda执行的时候是存在的

  • lambda表达式捕获的都是局部变量，这些变量在函数结束后就不复存在了

  • void fun1() {
        size_t a = 12;//局部变量
        //可调用对象lmd包含a的引用
        auto k = [&a] {return a;};
        a = 0;
        auto k = lmd();//k为0，lmd保存a的引用，而非拷贝
    }
    

• 隐式捕获

  除了显式列出我们希望使用的来自所在函数的局部变量之外，还可以根据lambda表达式的代码来推断我们要使用哪些变量。

  在捕获列表中写一个=或者&：

  • &：采用引用捕获方式

    [&] (const string &str) {return str.size() > size;};
    

  • =：采用值捕获方式

    [=] (const string &str) {return str.size() > size;};
    

  • 混合捕获，捕获列表中的第一个元素必须是=或者&，指定了默认的捕获方式；显式捕获方式必须和隐式捕获方式不同

    {
        size_t sz = 10;
        ostream os;
        char c = 'cc';
        //os隐式捕获，引用捕获方式
        //c显式捕获，值捕获方式
        [&,c] (const string &s) {os << s << c;};
        //os显式捕获，引用捕获方式
        //c隐式捕获，值捕获方式
        [=, &os] (const string &s) {os << s << c;};
    }
    
    

• 可变lambda表达式

  默认情况下，对于一个值拷贝的变量，lambda表达式不会改变其值。如果希望能改变一个被捕获的变量的值，要在参数裂变首加上关键字mutable

  • 值捕获

  void fun() {
      size_t a = 12;//局部变量
      //加了mutable关键字，f可以改变它所捕获的变量的值
      auto lmd = [a] () mutable {return ++a;};//值捕获
      a = 0;
      //由于被捕获变量的值是在lambda创建时拷贝，因此随后对其的修改不会影响到lambda内对应的值
      auto k = lmd();//k=13
  }
  

  • 引用捕获

  void fun() {
      size_t a = 13;
      //a是一个非const变量的引用
      //可以通过f中的引用来改变它
      auto lmd = [&a] {return ++a;};//引用捕获
      a = 0；
      auto k = lmd();//k为1
  }
  

• lambda表达式的返回类型

  如果编写的lambda表达式的函数体只包含一个单一的return语句，则不需要指定返回类型。

  如果lambda表达式的函数体包含return之外的任何语句，则返回void。

  //错误，编译器推断lambda表达式返回void，但实际返回了一个int
  [] (int i) {if (i < 0) return -i;else return i;}
  
  //正确，尾置返回类型
  [] (int i) -> int {if (i < 0) return -i;else return i;}
  

什么是bind函数？

bind函数是一个通用的函数适配器，它接受一个可调用对象生成一个新的可调用对象。

bind的一般形式：

auto fun = bind(fun1, para_list);
//fun本身是一个可调用对象
//para_list是一个逗号分隔的参数列表

为什么要使用bind？

使用std::bind统一了可调用对象的各种操作，使得不同类型的可调用对象具有相同的调用形式。

什么是function类型

std::function是一个可调用对象包装器，是一个类模板，当创建一个具体的function类型时我们必须提供额外的信息。可以容纳除了类成函数指针之外的所有可调用对象，并保存起来。

//声明一个function类型，接受两个int，返回一个int的可调用对象
function<int<int, int>>

#include <iostream>
#include <functional>
using namespace std;
using namespace placeholders;//占位符命名空间
class A {
public:
    void fun_3(int k, int m) {
        cout << k <<" "<< m << endl;
    }
};

void fun(int x, int y, int z) {
    cout << x <<"  "<< y <<"  "<< z << endl;
}

void fun_2(int &a, int &b) {
    a++;
    b++;
    cout << a <<"  "<< b << endl;
}

int main(int argc, const char * argv[]) {
    auto f1 = bind(fun, 1, 2, 3); //表示绑定函数fun的第一，二，三个参数值为： 1 2 3
    f1(); //print:1  2  3

    auto f2 = bind(fun, _1, _2, 3);
    //表示绑定函数fun的第三个参数为3，而fun的第一，二个参数分别对应f2的第一，二个参数
    f2(1, 2);//print:1  2  3

    auto f3 = bind(fun, _2, _1, 3);
    //表示绑定函数fun的第三个参数为3，而fun的第一，二个参数分别对应f3的第二，一个参数
    //注意： f2和f3的区别，占位符的顺序不一样
    f3(1, 2);//print:2  1  3

    int n = 2;
    int m = 3;

    auto f4 = bind(fun_2, n, _1);
    //表示绑定函数fun_2的第一个参数为n，而fun_2的第二个参数对应f4的第一个参数
    f4(m); //print:3  4

    cout << n << endl;//print:2  说明：bind对于预先绑定的函数参数是通过值传递的
    cout << m << endl;//print:4  说明：bind对于不事先绑定的参数，通过placeholders占位符传递的参数是通过引用传递的
    
    A a;
    auto f5 = bind(&A::fun_3, a, _1, _2);
    //表示绑定函数fun_3的第一、二个参数对应f5的第一、二个参数，a为绑定对象
    f5(10, 20);//print:10 20

    function<void(int, int)> fc = bind(&A::fun_3, a, _1, _2);
    //function将bind创建的对象保存起来，绑定函数fun_3的第一、二个参数对应fc的第一、二个参数
    fc(10, 20);//print:10 20

    return 0;
}