c++11特性(3)

闭包

什么是闭包

闭包有很多定义，一种说法是，带有上下文的函数。说白了就是有状态的函数。更直接一点，不就是个类吗？换了个名字而已

一个函数，带上了状态就变成闭包了。那么什么叫做带上状态呢？意思是这个闭包有属于自己的变量，这些个变量的值是创建闭包的时候设置的，并且在调用闭包的时候，可以访问这些变量
函数是代码，状态是一组变量，将代码和一组变量捆绑(bind)就形成了闭包。
闭包的状态捆绑，必须发生在运行时。

闭包的实现

仿函数：重载operator()

class MyFunctor
{
public:
    MyFunctor(int tmp):round(tmp){}
    int operator()(int tmp){return tmp + round;}

private:
    int round;
};


int main()
{
    int round = 2;
    MyFuntor f(round);	//调用构造函数
    cout << "result " << f(1) << endl;	//operator()(int tmp)
    return 0;
}

仿函数：重载operator()

class MyFunctor
{
private:
  int round;
public:
  MyFunctor(int tmp):round(tmp){};
  int operator()(int tmp)
  {
    return tmp + round;
  }
};

void test1()
{
  int round = 2;
  //调用构造函数
  MyFunctor f(round);
  //operator()(int tmp)
  cout << "reslut = " << f(1) << endl;
}

std::bind绑定器

std::function
在c++中，可调用实体包括：函数、函数指针、函数引用、可以隐式转换为函数指定的对象，或者实现了operator()对象。
c++11中，新增加了一个std::function类模板，它是对c++中现有的可调用实体的一种类型安全的包裹。通过指定它的模板参数，它可以用统一的方式处理函数、函数对象、函数指针，并允许保存和延迟执行它们。

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

void func(void)
{
    //普通全局函数
    cout << __func__ << endl;
}

class Foo
{
public:
    static int foo_func(int a)
    {
        //类中的静态函数
        cout << __func__ << "(" << a << ")->:";
        return a;
    }
};

class Bar
{
public:
    int operator()(int a)
    {
        //仿函数
        cout<< __func__ << "(" << a << ")->";
        return a;
    }
};

int main()
{
    //绑定一个普通函数
    function<void(void)> f1 = func;
    f1();
    
    //绑定类中的静态函数
    function<int(int)>	f2 = Foo::foo_func;
    cout << f2(111) << endl;
    
    //绑定一个仿函数
    Bar obj;
    f2 = obj;
    cout << f2(222) << endl;
    return 0;
}

std::function对象最大的作用是实现函数的回调，使用者需要注意，他不能被用来检查相等或者不相等，但是可以与NULL或者nullptr进行比较
std::bind
bind是这样一种机制，他可以预先把指定可调用实体的某些参数绑定到已有的变量，产生一个新的可调用实体，这种机制在回调函数的使用过程中也颇为有用

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

void test2()
{
  bind(funcbind, 1, 2)(); //输出12
  bind(funcbind, std::placeholders::_1, 2)(1);
  using namespace std::placeholders;
  bind(funcbind, 2, _1)(1); //输出 2 1
  bind(funcbind, 2, _2)(1, 2);  //输出 2 2
  bind(funcbind, _1, _2)(1, 2); //输出 1 2
  bind(funcbind, _2, _1)(1, 2); //输出 2 1

  //err 调用时没有第二个参数
  //bind(funcbind, 2, _2)(1);
}

lambda表达式

lambda表达式基础使用
lambda表达式是一个匿名函数
c++11中的lambda表达式用于定义并创建匿名的函数对象，以简化编程工作。
lambda表达式的基本构成：

1. 函数对象参数

[],标识一个lambda的开始，这部分必须存在，不能省略。函数对象参数是传递给编译器自动生成的函数对象类的构造函数的。函数对象参数只能使用那些到定义lambda为止时lambda所在作用范围内可见的局部变量（包括lambda所在类this）。函数对象参数有以下形式：

• n 空。没有使用任何函数对象参数。
• n =。函数体内可以使用lambda所在作用范围内所有可见的局部变量（包括lambda所在类的this），并且是值传递方式（相当于编译器自动为我们按值传递了所有局部变量）
• n &。函数体内可以使用lambda所在作用范围内所有可见的局部变量（包括lambda所在类的this），并且是引用传递方式（相当于编译器自动为我们按引用传递了所有局部变量）。
• n this。函数体内可以使用lambda所在类中的成员变量。
• n a。将a按值进行传递。按值进行传递时，函数体内不能修改传递进来的a的拷贝，因为默认情况下函数是const的，要修改传递进来的a的拷贝，可以添加mutable修饰符。
• n &a。 将a按引用进行传递。
• n a, &b。 将a按值进行传递，b按引用进行传递
• n =, &a, &b。除了a,b按引用进行传递外，b按引用进行传递。
• n &, a, b。除了ab按照值进行传递外，其他采纳数都按引用进行传递。

2. 操作符重载函数参数

标识重载()操作符的参数，没有参数时，这部分可以省略。参数可以通过按值（如：(a,b)）和按引用（如：(&a, &b)）两种方式进行传递。

3. 可修改标识符

mutable声明，这部分可以省略。按值传递函数对象参数时，加上mutable修饰符后，可以修改按值传递进来的拷贝（注意是能修改拷贝，而不是值本身）。

4. 错误抛出标识符

exception声明，这部分也可以省略。exception声明用于指定函数抛出的异常，如抛出整形的异常，可以使用throw(int)

5. 函数返回值

->返回值类型，表示函数返回值的类型，当返回值为void，或者函数体中只有一处return的地方(此时编译器可以自动推断出返回值类型)时，这部分可以省略。

6. 函数体

{}，标识函数的实现，这部分不能省略，但函数体可以为空

lambda类型
lambda表达式的类型在c++11中被称为“闭包类型”，每一个lambda表达式则会产生一个临时对象(右值)。因此严格的讲，lambda函数并非函数指针

不过c++11标准却允许lambda表达式向函数指针的转换，但前提是lambda函数没有捕获任何变量，且函数指针所示的函数原型，必须跟lambda函数有着相同的调用方式。

lambda表达式的价值在于，就地封装短小的功能闭包，可以极其方便的表达出我们希望执行的具体操作，并让上下文结合更加紧密。