背景
在C++11中,提供了std::function和std::bind两个方法来对可调用对象进行统一和封装。
一、什么是可调用对象
- 普通函数
- 函数指针
- 仿函数(类中重载()运算符)
- lambda 表达式
可调用对象:简单来说就是,可以像函数那样加个()就可以调用的对象
1.1 不同类型的可调用对象举例
int add(int, int) { return a+b; } // 普通函数
auto sub = [](int a, int b) { return a-b; } // lambda表达式
struct mod{
int operator()(int a, int b) { return a%b; } // 仿函数
};
上面三种不同类型的可调用对象,有相同的调用形式。假设,我们需要将上述函数对象做成一个函数表来调用,代码示例:
#include <iostream>
#include <map>
using namespace std;
int add(int a, int b) { return a+b; } // 普通函数
auto sub = [](int a, int b) { return a-b; }; // lambda表达式
struct mod{
int operator()(int a, int b) { return a%b; } // 仿函数
};
map<char, int(*)(int,int)> _table;
int main()
{
_table.insert({'+', add});
_table.insert({'-', sub});
// _table.insert({'-', mod()}); // 编译报错
int ret = _table['+'](10, 20); // 等价于add(10,20);
std::cout << ret << std::endl;
ret = _table['-'](30, 20); // 等价于sub(30,20);
std::cout << ret << std::endl;
// ret = _table['%'](10, 2);
// std::cout << ret << std::endl;
return 0;
}
仿函数插入失败,这个时候,function登场!
二、function函数包装器
std::function是一个函数包装器,包含在头文件#include《functional》中。该函数包装器模板能包装任何类型的可调用实体,如普通函数、函数对象、lambda表达式。
2.1 function 完成1.1函数表制作
#include <iostream>
#include <map>
#include <functional> // 包含头文件
using namespace std;
int add(int a, int b) { return a+b; } // 普通函数
auto sub = [](int a, int b) { return a-b; }; // lambda表达式
struct mod{
int operator()(int a, int b) { return a%b; } // 仿函数
};
// 重新声明map
map<char, function<int(int,int)>> _table;
int main()
{
function<int(int,int)> func1 = add;
function<int(int,int)> func2 = sub;
function<int(int,int)> func3 = mod();
_table.insert({'+', func1});
_table.insert({'-', func2});
_table.insert({'%', func3});
int ret = _table['+'](10, 20); // 等价于add(10,20);
std::cout << ret << std::endl;
ret = _table['-'](30, 20); // 等价于sub(30,20);
std::cout << ret << std::endl;
ret = _table['%'](10, 2); // 等价于mod(10,2);
std::cout << ret << std::endl;
return 0;
}
运行结果:
2.2 function 基本语法
完整代码示例
#include <iostream>
#include <functional>
using namespace std;
void func1(int a) { cout << a << endl; }
class A{
public:
A(string name) : name_(name){}
void func3(int i) const {
cout <<name_ << ", " << i << endl;
}
private:
string name_;
};
int main() {
cout << "----------- main1 -----------------" << endl;
//1. 保存普通函数
std::function<void(int a)> func1_;
func1_ = func1;
func1_(2);
//2. 保存lambda表达式
cout << "------- main2 -----------------" << endl;
std::function<void()> func2_ = [](){cout << "hello lambda" << endl;};
func2_(); //hello world
//3 保存成员函数
cout << "\n---------- main3 -----------------" << endl;
std::function<void(const A&,int)> func3_ = &A::func3; // 别忘了&符号
A a("lwang");
func3_(a, 1);
return 0;
}
运行结果:
三、bind 绑定器
- 只是绑定函数,参数需要自己传;
- 绑定函数的时候,也把参数绑定
3.1 作用:
bind 函数可以看做是一个通用的函数适配器,它接收一个可调用对象,生成一个新的可调用对象来适应原对象的参数列表。
3.2 用法:
template<class F, class… Args>
bind(F&&f, Args&&… args);
auto newCallable = bind(callable, arg_list);
3.3 代码示例
#include <iostream>
#include <functional>
using namespace std;
class A {
public:
void fun_3(int k,int m) {
cout<<"print: k="<<k<<",m="<<m<<endl;
}
};
void fun_1(int x, int y, int z) {
cout<<"print: x=" <<x<<", y="<< y << ", z=" <<z<<endl;
}
void fun_2(int &a,int &b) {
a++;
b++;
cout<<"print: a=" <<a<<",b="<<b<<endl;
}
int main(int argc, char * argv[])
{
//f1的类型为 function<void(int, int, int)>
auto f1 = std::bind(fun_1, 1, 2, 3); //表示绑定函数 fun 的第一,二,三个参数值为: 1 2 3
f1();
//表示绑定函数 fun 的第三个参数为 3,而fun 的第一,二个参数分别由调用 f2 的第一,二个参数 指定3 可变模板参数
auto f2 = std::bind(fun_1, placeholders::_1,placeholders::_2,3);
f2(1,2);
//表示绑定函数 fun 的第三个参数为 3,而fun 的第一,二个参数分别由调用 f3 的第二,一个参数 指定 //注意: f2 和 f3 的区别。
auto f3 = std::bind(fun_1,placeholders::_2,placeholders::_1,3);
f3(1,2);
int m = 2;
int n = 3;
//表示绑定fun_2的第一个参数为n, fun_2的第二个参数由调用f4的第一个参数(_1)指定。
auto f4 = std::bind(fun_2, placeholders::_1, n);
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
A a;
//f5的类型为 function<void(int, int)>
auto f5 = std::bind(&A::fun_3, a, placeholders::_1,placeholders::_2); //使用 auto关键字
f5(10,20);//调用a.fun_3(10,20),print: k=10,m=20
std::function<void(int,int)> fc = std::bind(&A::fun_3, a,std::placeholders::_1,std::placeholders::_2);
fc(10,20); //调用a.fun_3(10,20) print: k=10,m=20
return 0;
}
3.3.1 运行结果:
3.3. 2 结论:
bind对于不事先绑定的参数,即通过std::placeholders传递的参数是通过引用传递的,bind对于预先绑定的函数参数是通过值传递的。
文章参考于<零声教育>的C/C++linux服务期高级架构。