C++11 function、bind、可变参数模板-阿里云开发者社区

在设计回调函数的时候，无可避免地会接触到可回调对象。在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;
}

C++11 function、bind、可变参数模板

function的用法

1. 保存普通函数

2. 保存lambda表达式

3. 保存成员函数

bind用法

可变模板参数

可变模版参数的展开

可变模版参数函数

递归函数方式展开参数包

逗号表达式展开参数包

热门文章

最新文章

相关课程

相关电子书

探索云世界

热门

云计算

大数据

云原生

人工智能

数据库

开发与运维

活动广场

任务中心

训练营

直播

乘风者计划

下载

镜像站

技术资料

C++11 function、bind、可变参数模板

function的用法

1. 保存普通函数

2. 保存lambda表达式

3. 保存成员函数

bind用法

可变模板参数

可变模版参数的展开

可变模版参数函数

递归函数方式展开参数包

逗号表达式展开参数包

热门文章

最新文章

相关课程

相关电子书