lambda表达式和functional以及bind

简单使用

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

int main()
{
  int a = 3;
  auto func =  [a](int b) -> int{
        return a+b;
  };
  int b = 4;
  int c = func(b);
  cout << c << endl;
}

上面是一个最简单的例子[a]表示捕获lambda表达式外面的变量a，也就是外lambda表达式里面可以使用这个a变量，捕获方式有值捕获和引用捕获，int b是形参，->int表示返回值是int，func是把这个lambda表示存储起来。

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

int func(int a, int b)
{
    return a+b;
}

int main()
{
  int a = 3;
  int b = 4;
  function<int(int, int)> fun = func;
  cout << fun(a, b) << endl;
}

function能够将一个函数包裹成一个对象，然后像使用函数一样使用int(int, int)括号外面的int是指返回类型，里面的是形参类型。

lambda表达式

值捕获和引用捕获

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

int main()
{
  int a = 10; 
  auto func = [a](int b)->int{ return a + b; };
  int b = 20;
  cout << func(b) << endl;
}

当捕获的方式是值捕获时，lambda外边的变量到lambda里面就变成了左值，也就是常量了，并且是在lambda表达式创建的时候传入的。

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

int main()
{
  int a = 10; 
  int b = 20;
  auto func = [&a, &b](){ a++; b++; };
  func();
  cout << a << endl << b << endl;
}

当以引用的方式捕获时，在lambda表达式里修改了变量的值，外面的也修改了，修改的是同一个内存里面的。

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

int main()
{
  int a = 10; 
  int b = 20;
  auto func = [=]()->int{ return a + b; };
  cout << func() << endl;
}

=号是以值捕获的方式捕获lambda前面声明的所有变量。
&号是以引用捕获的方式捕获lambda前面声明的所有变量。

mutable

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

int main()
{
  int a = 10; 
  int b = 20;
  auto func = [a, b]() mutable { a++; b++; cout << a << endl << b << endl;};
  func();
  cout << a << endl << b << endl;
}

mutable关键字就是允许在lambda表达式里面修改值捕获变量的值，因为此时lambda里面的a和外面的a是两个完全不同的变量，地址都不同了。

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

int main()
{
  int a = 10; 
  int b = 20;
  auto func = [a, b]() mutable {cout << &a << endl << &b << endl;};
  func();
  cout << &a << endl << &b << endl;
}

functional

#include <functional>
#include <iostream>

int foo(int para) {
    return para;
}

int main() {
    // std::function 包装了一个返回值为 int, 参数为 int 的函数
    std::function<int(int)> func = foo;

    int important = 10;
    std::function<int(int)> func2 = [&](int value) -> int {
        return 1+value+important;
    };
    std::cout << func(10) << std::endl;
    std::cout << func2(10) << std::endl;
}

function的作用就是讲一个函数或者一个lambda表达式包裹成一个function对象，在传参和使用的时候很方便。

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

class Functor 
{
public:
    int operator()(int n) {
        m_n = n;
        return n;
    }

    int test() {
        return m_n;
    }

    int m_n;
};
//bind

int main()
{
    Functor funtor;
    funtor.m_n = 5;
    std::function<int(Functor*)> f4 = &Functor::test;
    cout << f4(&funtor) << endl;
    return 0;
}

包装类成员函数的写法，因为成员函数默认会传入this指针。

std::bind

#include <functional>
#include <iostream>
using namespace std;
void foo(int a, int b, int c) {
    cout << a << endl << b << endl << c << endl;
}
int main() {
    // 将参数1,2绑定到函数 foo 上，但是使用 std::placeholders::_1 来对第一个参数进行占位
    auto bindFoo = std::bind(foo, std::placeholders::_2, std::placeholders::_1, 3);
    // 这时调用 bindFoo 时，只需要提供第一个参数即可
    bindFoo(1, 2);
}

std::bind的作用就是将形参和传入的实参的位置做一个绑定，也可以绑定默认的参数，上面的例子std::placeholders::_2表示第一个位置的形参适合第二个实参是对应的。

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

class MyPair
{
    double m_a, m_b;
public:
    MyPair(double a, double b): m_a(a), m_b(b)
    {

    }
    double multiply()
    {
        return m_a * m_b;
    }
};

int main()
{
    MyPair ten_two(2.0, 3.0);
    auto bind = std::bind(&MyPair::multiply, std::placeholders::_1);
    cout << bind(ten_two) << endl;
}

bind绑定成员函数的方法买还是由于默认会传入一个this的原因，bind还有其他的绑定形式，有兴趣可以自己探究。