在设计回调函数的时候，无可避免地会接触到可回调对象。在C++11中，提供了std::function和 std::bind两个方法来对可回调对象进行统一和封装。 C++语言中有几种可调用对象：函数、函数指针、lambda表达式、bind创建的对象以及重载了函数调用 运算符的类。 和其他对象一样，可调用对象也有类型。例如，每个lambda有它自己唯一的（未命名）类类型；函数及函数指针的类型则由其返回值类型和实参类型决定。

function的用法

1. 保存普通函数

//保存普通函数
void func1(int a)
{
cout << a << endl;
}
//1. 保存普通函数
std::function<void(int a)> func;
func = func1;
func(2); //2

2. 保存lambda表达式

std::function<void()> func_1 = [](){cout << "hello world" << endl;};
func_1(); //hello world

3. 保存成员函数

//保存成员函数
class A{
public:
A(string name) : name_(name){}
void func3(int i) const {cout <<name_ << ", " << i << endl;}
private:
string name_;
};
//3 保存成员函数
std::function<void(const A&,int)> func3_ = &A::func3;
A a("darren");
func3_(a, 1);

#include <iostream>
#include <functional> // 添加头文件 functional
using namespace std;
// function 类似c的函数指针
//保存普通函数
void func1(int a)
{
    cout << a << endl;
}
//保存成员函数
class A {
public:
    A(string name) : name_(name) {}
    void func3(int i) const { cout << name_ << ", " << i << endl; }
    // void func3(string str) const {cout <<name_ << ", " << str << endl;}

    //    std::bind((void(A::*)(int, int))&A::fun_4
    void func4(int k, int m)
    {
        cout << "func4 print: k=" << k << ",m=" << m << endl;
    }
    //    std::bind((void(A::*)(string))&A::fun_4
    void func4(string str) {
        cout << "func4 print: str=" << str << endl;
    }
private:
    string name_;
};
int main()
{
    cout << "main1 -----------------" << endl;
    //1. 保存普通函数
    std::function<void(int a)> func1_;
    func1_ = func1;
    func1_(2);   //2
    cout << "\n\nmain2 -----------------" << endl;
    //2. 保存lambda表达式
    std::function<void()> func2_ = []() {cout << "hello lambda" << endl; };
    func2_();  //hello world
    cout << "\n\nmain3 -----------------" << endl;
    //3 保存成员函数
    std::function<void(const A&, int)> func3_ = &A::func3;
    A a("darren");
    func3_(a, 1);
    //4.重载函数
    std::function<void(int, int)> func4_1 = std::bind((void(A::*)(int, int)) & A::func4, a, std::placeholders::_1, std::placeholders::_2);
    func4_1(1, 2);
    auto f_str = std::bind((void(A::*)(string)) & A::func4, a, std::placeholders::_1);
    f_str("darren");
    std::function<void(string)> f_str2 = std::bind((void(A::*)(string)) & A::func4, &a, std::placeholders::_1);
    return 0;
}

bind用法

可将bind函数看作是一个通用的函数适配器，它接受一个可调用对象，生成一个新的可调用对象来“适应”原对象的参数列表。 调用bind的一般形式：auto newCallable = bind(callable, arg_list);

其中，newCallable本身是一个可调用对象，arg_list是一个逗号分隔的参数列表，对应给定的callable的参数。即，当我们调用newCallable时，newCallable会调用callable,并传给它arg_list中的参数。

arg_list中的参数可能包含形如n的名字，其中n是一个整数，这些参数是“占位符”，表示newCallable的参 数，它们占据了传递给newCallable的参数的“位置”。数值n表示生成的可调用对象中参数的位置：1为 newCallable的第一个参数，_2为第二个参数，以此类推。

#include <iostream>
#include <functional>
using namespace std;
class A
{
public:
    // 重载fun_3，主要bind的时候需要
//    std::bind((void(A::*)(int, int))&A::fun_3
    void fun_3(int k, int m)
    {
        cout << "fun_3 a = " << a << endl;
        cout << "print: k=" << k << ",m=" << m << endl;
    }
    //    std::bind((void(A::*)(string))&A::fun_3
    void fun_3(string str) {
        cout << "print: str=" << str << endl;
    }
    int a;
};
void fun_1(int x, int y, int z)
{
    cout << "fun_1 print: x=" << x << ",y=" << y << ",z=" << z << endl;
}
void fun_2(int& a, int& b)
{
    a++;
    b++;
    cout << "print: a=" << a << ",b=" << b << endl;
}
void func2_1(int a, int b)
{
    cout << "func2_1 a + b = " << a + b << endl;
}
int func2_1(string a, string b)
{
    cout << "func2_1 a + b = " << a << b << endl;
    return 0;
}
int main()
{
    auto f2_1_1 = std::bind((void(*)(int, int))func2_1, 1, 2); //表示绑定函数 fun 的第一，二，三个参数值为： 1 2 3
    f2_1_1(); //print: x=1,y=2,z=3
#if 1
    //f1的类型为 function<void(int, int, int)>
    cout << "\n\nstd::bind(fun_1, 1, 2, 3) -----------------\n";
    auto f1 = std::bind(fun_1, 1, 2, 3); //表示绑定函数 fun 的第一，二，三个参数值为： 1 2 3    运行的时候不需要再传递参数
    f1(); //print: x=1,y=2,z=3
    cout << "\n\nstd::bind(fun_1, 10, 20, 30) -----------------\n";
    auto f11 = std::bind(fun_1, 10, 20, 30); //表示绑定函数 fun 的第一，二，三个参数值为： 1 2 3
    f11();
    cout << "\n\nstd::bind(fun_1, placeholders::_1,placeholders::_2, 3) -----------------\n";
    auto f2 = std::bind(fun_1, placeholders::_1, placeholders::_2, 3);       // 锁定第三个参数  ,   绑定参数是从1开始的,placeholders::_1(占位符),和数组索引有所不同
    //表示绑定函数 fun 的第三个参数为 3，而fun 的第一，二个参数分别由调用 f2 的第一，二个参数指定
    f2(1, 2);//print: x=1,y=2,z=3
    f2(10, 21, 30); // 传入30也没有用
#endif
//    cout << "\n\nstd::bind(fun_1,placeholders::_2,placeholders::_1,3) -----------------\n";
//    auto f3 = std::bind(fun_1,placeholders::_2,placeholders::_1,3);
//    //表示绑定函数 fun 的第三个参数为 3，而fun 的第一，二个参数分别由调用 f3 的第二，一个参数指定
//    //注意： f2  和  f3 的区别。
//    f3(1,2);//print: x=2,y=1,z=3
//    cout << "\n\nstd::bind(fun_2, placeholders::_1, n) -----------------\n";
//    int m = 2;
//    int n = 3;
//    auto f4 = std::bind(fun_2, placeholders::_1, n); //表示绑定fun_2的第一个参数为n, fun_2的第二个参数由调用f4的第一个参数（_1）指定。
//    f4(m); //print: m=3,n=4
//    cout<<"m="<<m<<endl;//m=3  说明：bind对于不事先绑定的参数，通过std::placeholders传递的参数是通过引用传递的,如m
//    cout<<"n="<<n<<endl;//n=3  说明：bind对于预先绑定的函数参数是通过值传递的，如n
//#if 1
    cout << "\n\nstd::bind(&A::fun_3, &a,placeholders::_1,placeholders::_2) -----------------\n";
    A a;
    a.a = 10;
    //f5的类型为 function<void(int, int)>
    auto f5 = std::bind((void(A::*)(int, int)) & A::fun_3, &a, 40, 50); //使用auto关键字
    f5(10, 20);//调用a.fun_3(10,20),print: k=10,m=20
    cout << "\n\nstd::bind(&A::fun_3, &a2,placeholders::_1,placeholders::_2) -----------------\n";
    A a2;
    a2.a = 20;
    //f5的类型为 function<void(int, int)>
    auto f6 = std::bind((void(A::*)(int, int)) & A::fun_3, &a2, placeholders::_1, placeholders::_2); //使用auto关键字
    f6(10, 20);
//    cout << "\n\nstd::bind(&A::fun_3, a,std::placeholders::_1,std::placeholders::_2) -----------------\n";
//    std::function<void(int,int)> fc = std::bind((void(A::*)(int, int))&A::fun_3, a,std::placeholders::_1,std::placeholders::_2);
//    fc(10,20);   //调用a.fun_3(10,20) print: k=10,m=20
//    fc = std::bind((void(A::*)(int, int))&A::fun_3, a2,std::placeholders::_1,std::placeholders::_2);
    cout << "\n\nstd::bind(&A::fun_3, a,std::placeholders::_1,std::placeholders::_2) ----\n";
    auto f_str = std::bind((void(A::*)(string)) & A::fun_3, a, std::placeholders::_1);
    f_str("darren");
    //#endif
    return 0;
}

可变模板参数

C++11的新特性--可变模版参数（variadic templates）是C++11新增的最强大的特性之一，它对参数进 行了高度泛化，它能表示0到任意个数、任意类型的参数

可变模版参数的展开

可变参数模板语法

template<class... T> 

void f(T... args);

上面的可变模版参数的定义当中，省略号的作用有两个：

1. 声明一个参数包T... args，这个参数包中可以包含0到任意个模板参数；

2. 在模板定义的右边，可以将参数包展开成一个一个独立的参数。

上面的参数args前面有省略号，所以它就是一个可变模版参数，我们把带省略号的参数称为“参数包”， 它里面包含了0到N（N>=0）个模版参数。我们无法直接获取参数包args中的每个参数的，只能通过展 开参数包的方式来获取参数包中的每个参数，这是使用可变模版参数的一个主要特点，也是最大的难 点，即如何展开可变模版参数。 可变模版参数和普通的模版参数语义是一致的，所以可以应用于函数和类，即可变模版参数函数和可变 模版参数类，然而，模版函数不支持偏特化，所以可变模版参数函数和可变模版参数类展开可变模版参 数的方法还不尽相同，下面我们来分别看看他们展开可变模版参数的方法。

可变模版参数函数

#include <iostream>
using namespace std;
template <class... T>
void f(T... args)
{
cout << sizeof...(args) << endl; //打印变参的个数
}
int main()
{
f(); //0
f(1, 2); //2
f(1, 2.5, ""); //3
return 0;
}

上面的例子中，f()没有传入参数，所以参数包为空，输出的size为0，后面两次调用分别传入两个和三个 参数，故输出的size分别为2和3。由于可变模版参数的类型和个数是不固定的，所以我们可以传任意类 型和个数的参数给函数f。这个例子只是简单的将可变模版参数的个数打印出来，如果我们需要将参数包 中的每个参数打印出来的话就需要通过一些方法了。 展开可变模版参数函数的方法一般有两种：

1. 通过递归函数来展开参数包

2. 是通过逗号表达式来展开参数包。

下面来看看如何用这两种方法来展开参数包。

递归函数方式展开参数包

通过递归函数展开参数包，需要提供一个参数包展开的函数和一个递归终止函数，递归终止函数正是用来终止递归的

#include <iostream>
using namespace std;
//递归终止函数
void print()
{
    cout << "empty" << endl;
}
//展开函数
template <class T, class ...Args>
void print(T head, Args... rest)
{
    cout << "parameter " << head << endl;
    print(rest...);
}
int main(void)
{
    print(1,2,3,4);
    return 0;
}

上例会输出每一个参数，直到为空时输出empty。展开参数包的函数有两个，一个是递归函数，另外一 个是递归终止函数，参数包Args...在展开的过程中递归调用自己，每调用一次参数包中的参数就会少一 个，直到所有的参数都展开为止，当没有参数时，则调用非模板函数print终止递归过程。

上面的递归终止函数还可以写成这样：

template <class T>
void print(T t)
{
    cout << t << endl;
}

逗号表达式展开参数包

递归函数展开参数包是一种标准做法，也比较好理解，但也有一个缺点,就是必须要一个重载的递归终止 函数，即必须要有一个同名的终止函数来终止递归，这样可能会感觉稍有不便。有没有一种更简单的方 式呢？其实还有一种方法可以不通过递归方式来展开参数包，这种方式需要借助逗号表达式和初始化列 表。比如前面print的例子可以改成这样：

#include <iostream>
using namespace std;
template <class T>
void printarg(T t)
{
    cout << t << endl;
}
template <class ...Args>
void expand(Args... args)
{
    int arr[] = {(printarg(args), 0)...};
}
int main()
{
    expand(1,2,3,4);
    return 0;
}

这个例子将分别打印出1,2,3,4四个数字。这种展开参数包的方式，不需要通过递归终止函数，是直接在 expand函数体中展开的, printarg不是一个递归终止函数，只是一个处理参数包中每一个参数的函数。expand函数中的逗号表达式：(printarg(args), 0)，先执行printarg(args)，再得到逗号表达式的结果0。 同时还用到了C++11的另外一个特性——初始化列表，通过初始化列表来初始化一个变长数组, {(printarg(args), 0)...}将会展开成((printarg(arg1),0), (printarg(arg2),0), (printarg(arg3),0), etc... )，最 终会创建一个元素值都为0的数组int arr[sizeof...(Args)]。由于是逗号表达式，在创建数组的过程中会先 执行逗号表达式前面的部分printarg(args)打印出参数，也就是说在构造int数组的过程中就将参数包展开 了，这个数组的目的纯粹是为了在数组构造的过程展开参数包。我们可以把上面的例子再进一步改进一 下，将函数作为参数，就可以支持lambda表达式了，从而可以少写一个递归终止函数了，具体代码如下：

#include <iostream>
using namespace std;
template<class F, class... Args>void expand(const F& f, Args&&...args)
{
    //这里用到了完美转发
    initializer_list<int>{(f(std::forward< Args>(args)),0)...};
}
int main()
{
    expand([](int i){cout<<i<<endl;}, 1,2,3);
    return 0;
}