C++11中的std::function 和 std::bind

std::function

#include < functional>

1、定义

在C++中，可调用实体主要包括函数，函数指针，函数引用，可以隐式转换为函数指定的对象，或者实现了opetator()的对象（即C++98中的functor)。C++11中，新增加了一个std::function对象，std::function的实例可以对任何可以调用的目标实体进行存储、复制、和调用操作，对C++中现有的可调用实体的一种类型安全的包裹。

通过std::function对C++中各种可调用实体（普通函数、函数指针、Lambda表达式、仿函数、类成员函数以及类静态函数等）的封装，形成一个新的可调用的std::function对象，让我们不再纠结那么多可调用的实体，有种“万众归一”的调调，一切变得简单粗暴。

可以把function看成是一种表示函数的数据类型，就像函数对象一样。只不过普通的数据类型表示的是数据，function表示的是函数这个抽象概念。

简要来说：std::function是将所有可调用的实体封装起来，形成了一个新的std::function对象，用户在使用的时候不需要再去一一调用实体，只需要使用新的std::function来调用各实体

2、原型说明：

template <class T> function; // undefined
template <class Ret, class... Args> class function<Ret(Args...)>;
R是返回值类型，
Args是函数的参数类型，
实例一个std::function对象很简单，就是将可调用对象的返回值类型和参数类型作为模板参数传递给std::function模板类。比如：

通常std::function是一个函数对象类，它包装其它任意的函数对象，被包装的函数对象具有类型为T1, …,TN的N个参数，并且返回一个可转换到R类型的值。

std::function<void()> f1;
std::function<int (int , int)> f2;

关于可调用实体转换为std::function对象需要遵守以下两条原则：

• 转换后的std::function对象的参数能转换为可调用实体的参数；
• 可调用实体的返回值能转换为std::function对象的返回值。

3、举例说明：

例子1：
例子2

#include <iostream>
#include <vector>
#include <list>
#include <map>
#include <set>
#include <string>
#include <algorithm>
#include <functional>
#include <memory>
using namespace std;
 
//声明一个模板
typedef std::function<int(int)> Functional;
 
 
//normal function
int TestFunc(int a)
{
    return a;
}
 
//lambda expression
auto lambda = [](int a)->int{return a;};
 
//functor仿函数
class Functor
{
public:
    int operator() (int a)
    {
        return a;
    }
};
 
 
//类的成员函数和类的静态成员函数
class CTest
{
public:
    int Func(int a)
    {
        return a;
    }
    static int SFunc(int a)
    {
        return a;
    }
};
 
 
int main(int argc, char* argv[])
{
    //封装普通函数
    Functional obj = TestFunc;
    int res = obj(0);
    cout << "normal function : " << res << endl;
 
    //封装lambda表达式
    obj = lambda;
    res = obj(1);
    cout << "lambda expression : " << res << endl;
 
    //封装仿函数
    Functor functorObj;
    obj = functorObj;
    res = obj(2);
    cout << "functor : " << res << endl;
 
    //封装类的成员函数和static成员函数
    CTest t;
    obj = std::bind(&CTest::Func, &t, std::placeholders::_1);
    res = obj(3);
    cout << "member function : " << res << endl;
 
    obj = CTest::SFunc;
    res = obj(4);
    cout << "static member function : " << res << endl;
 
    return 0;
}

std::bind

#include < functional>

1、定义

bind是一种机制，可以预先把指定的可调用的实体的某些参数绑定到已有的变量，产生一个新的可调用实体。
std::bind是一个函数模板，就像是一个函数适配器，接受一个可调用对象，而生成一个新的可调用对象来适配原来的参数列表，该模板返回的是一个std::function对象。用该函数我们也能实现参数顺序的调整和给将指定参数设置成固定值。

可调用对象:

普通函数
lambda表达式
函数指针
仿函数(functor 重载括号运算符实现)
类成员函数
静态成员函数

2、函数原型

template< class F, class... Args >
/*unspecified*/ bind( F&& f, Args&&... args );
 
template< class R, class F, class... Args >
/*unspecified*/ bind( F&& f, Args&&... args );

f：一个可调用对象，它的参数将被绑定到args上。
args：绑定参数列表，参数会被值或占位符替换，其长度必须与f接收的参数个数一致。
调用std::bind的一般形式为：
auto newCallable = std::bind(callable, arg_list);
其中，newCallable本身是一个可调用对象，arg_list是一个逗号分隔的参数列表，对应给定的callable的参数。即，当我们调用newCallable时，newCallable会调用callable，并传递给它arg_list中的参数。

3、std::placeholders

占位符，通过查看functional文件可以看到c++11中有29个占位符，分别是_1~_29，一般情况下是写std::placeholders::_1这样子的。占位符的作用就是用来代表参数的，std::placeholders::_1表示的是std::bind得到的std::function对象被调用时，传入的第一个参数，而std::placeholders::_2则是第二个参数。
我们调整std::placeholders::_x在std::bind时的顺序，就可以起到调整参数顺序的作用了。此外，我们也可以在std::bind的时候不用std::placeholders::_x，而直接写成固定的值，这样子调用std::function存储的对象时，对应位置的参数将是固定值。

4、举例说明：

例子

#include <iostream>
using namespace std;
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 = std::bind(fun,1,2,3); //表示绑定函数 fun 的第一，二，三个参数值为： 1 2 3
    f1(); //print:1  2  3
 
    auto f2 = std::bind(fun, placeholders::_1,placeholders::_2,3);
    //表示绑定函数 fun 的第三个参数为 3，而fun 的第一，二个参数分别有调用 f2 的第一，二个参数指定
    f2(1,2);//print:1  2  3
 
    auto f3 = std::bind(fun,placeholders::_2,placeholders::_1,3);
    //表示绑定函数 fun 的第三个参数为 3，而fun 的第一，二个参数分别有调用 f3 的第二，一个参数指定
    //注意： f2  和  f3 的区别。
    f3(1,2);//print:2  1  3
 
 
    int n = 2;
    int m = 3;
 
    auto f4 = std::bind(fun_2, n,placeholders::_1);
    f4(m); //print:3  4
 
    cout<<m<<endl;//print:4  说明：bind对于不事先绑定的参数，通过std::placeholders传递的参数是通过引用传递的
    cout<<n<<endl;//print:2  说明：bind对于预先绑定的函数参数是通过值传递的
 
 
    A a;
    auto f5 = std::bind(&A::fun_3, a,placeholders::_1,placeholders::_2);
    f5(10,20);//print:10 20
 
    std::function<void(int,int)> fc = std::bind(&A::fun_3, a,std::placeholders::_1,std::placeholders::_2);
    fc(10,20);//print:10 20
 
    return 0;
}