在设计回调函数的时候，无可避免地会接触到可回调对象。在C++11中，提供了std::function和 std::bind两个方法来对可回调对象进行统一和封装。 C++语言中有几种可调用对象：函数、函数指针、lambda表达式、bind创建的对象以及重载了函数调用 运算符的类。 和其他对象一样，可调用对象也有类型。例如，每个lambda有它自己唯一的（未命名）类类型；函数及函数指针的类型则由其返回值类型和实参类型决定。
function的用法 1. 保存普通函数//保存普通函数
void func1(int a)
{
cout << a << endl;
}
//1. 保存普通函数
std::function func;
func = func1;
func(2); //2
std::function func_1 = [](){cout << "hello world" << endl;};
func_1(); //hello world //保存成员函数
class A{
public:
A(string name) : name_(name){}
void func3(int i) const {cout < func3_ = &A::func3;
A a("darren");
func3_(a, 1);
#include
#include // 添加头文件 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 < func1_;
func1_ = func1;
func1_(2); //2
cout << "\n\nmain2 -----------------" << endl;
//2. 保存lambda表达式
std::function func2_ = []() {cout << "hello lambda" << endl; };
func2_(); //hello world
cout << "\n\nmain3 -----------------" << endl;
//3 保存成员函数
std::function func3_ = &A::func3;
A a("darren");
func3_(a, 1);
//4.重载函数
std::function 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 f_str2 = std::bind((void(A::*)(string)) & A::func4, &a, std::placeholders::_1);
return 0;
}
可将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
#include
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
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="<
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
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 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
void f(T... args);
上面的可变模版参数的定义当中，省略号的作用有两个：
1. 声明一个参数包T... args，这个参数包中可以包含0到任意个模板参数；
2. 在模板定义的右边，可以将参数包展开成一个一个独立的参数。
上面的参数args前面有省略号，所以它就是一个可变模版参数，我们把带省略号的参数称为“参数包”， 它里面包含了0到N（N>=0）个模版参数。我们无法直接获取参数包args中的每个参数的，只能通过展 开参数包的方式来获取参数包中的每个参数，这是使用可变模版参数的一个主要特点，也是最大的难 点，即如何展开可变模版参数。 可变模版参数和普通的模版参数语义是一致的，所以可以应用于函数和类，即可变模版参数函数和可变 模版参数类，然而，模版函数不支持偏特化，所以可变模版参数函数和可变模版参数类展开可变模版参 数的方法还不尽相同，下面我们来分别看看他们展开可变模版参数的方法。
可变模版参数函数#include
using namespace std;
template
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
using namespace std;
//递归终止函数
void print()
{
cout << "empty" << endl;
}
//展开函数
template
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
void print(T t)
{
cout << t << endl;
}
递归函数展开参数包是一种标准做法，也比较好理解，但也有一个缺点,就是必须要一个重载的递归终止 函数，即必须要有一个同名的终止函数来终止递归，这样可能会感觉稍有不便。有没有一种更简单的方 式呢？其实还有一种方法可以不通过递归方式来展开参数包，这种方式需要借助逗号表达式和初始化列 表。比如前面print的例子可以改成这样：
#include
using namespace std;
template
void printarg(T t)
{
cout << t << endl;
}
template
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
using namespace std;
templatevoid expand(const F& f, Args&&...args)
{
//这里用到了完美转发
initializer_list{(f(std::forward< Args>(args)),0)...};
}
int main()
{
expand([](int i){cout< 欢迎分享，转载请注明来源：内存溢出
微信扫一扫
支付宝扫一扫
评论列表（0条）