目录
一. function包装器
1. 在题解上
2.bind 绑定
1.调整参数顺序
2.对类中函数的包装方法
一. function包装器
function包装器也叫作适配器。C++中的function本质是一个类模板，也是一个包装器。 那么我们来看看，我们为什么需要function呢？
ret = func(x);
// 上面func可能是什么呢？那么func可能是函数名？函数指针？函数对象(仿函数对象)？也有可能
是lamber表达式对象？所以这些都是可调用的类型！如此丰富的类型，可能会导致模板的效率低下！
为什么呢？我们继续往下看
template<class F, class T>
T useF(F f, T x)
{
static int count = 0;
cout << "count:" << ++count << endl;
cout << "count:" << &count << endl;
return f(x);
}
double f(double i)
{
return i / 2;
}
struct Functor
{
double operator()(double d)
{
return d / 3;
}
int main()
{
// 函数名
cout << useF(f, 11.11) << endl;
// 函数对象
cout << useF(Functor(), 11.11) << endl;
// lamber表达式
cout << useF([](double d)->double{ return d/4; }, 11.11) << endl;
return 0;
}代码打印：
通过上面的程序验证，我们会发现useF函数模板实例化了三份。
如何实现对函数传参的三种统一模板化调用？包装器
解决了：模板调用函数的效率低下，实例化多份的问题
template<class F, class T>
T useF(F f, T x)
{
static int count = 0;
cout << "count:" << ++count << endl;
cout << "count:" << &count << endl;
return f(x);
}
double f(double i)
{
return i / 2;
}
struct Functor
{
double operator()(double d)
{
return d / 3;
}
};
int main()
{
// 函数名
cout << useF(function<double(double)>(f), 11.11) << endl;
// 函数对象
Functor ft;
cout << useF(function<double(double)>(ft), 11.11) << endl;
// lamber表达式
cout << useF(function<double(double)>([](double d)->double { return d / 4; }), 11.11) << endl;
return 0;
}
实现了对象对 同类型 的不同函数处理的便捷调用，再也不用创建多个了，实现了优化
1. 在题解上
以150. 逆波兰表达式求值为例
class Solution {
public:
int evalRPN(vector<string>& tokens) {
stack<int> _st;
map<string,function<int(int,int)>> opFuncMap =
{
{"+",[](int x,int y)->int{return x+y;}},
{"-",[](int x,int y)->int{return x-y;}},
{"*",[](int x,int y)->int{return x*y;}},
{"/",[](int x,int y)->int{return x/y;}},
//这里还可以添加%其他东西，还是很好用的
};
for(auto& str : tokens)
{
if(opFuncMap.count(str) == 0)
{
_st.push(stoi(str));
}
else
{
int right=_st.top();
_st.pop();
int left=_st.top();
_st.pop();
_st.push(opFuncMap[str](left,right));
}
}
return _st.top();
}
};2.bind 绑定
- std::bind函数定义在头文件中，是一个函数模板，它就像一个函数包装器(适配器)，接受一个可调用对象（callable object），生成一个新的可调用对象来“适应”原对象的参数列表。
- 一般而言，我们用它可以把一个原本接收N个参数的函数fn，通过绑定一些参数，返回一个接收M个（M可以大于N，但这么做没什么意义）参数的新函数。
- 同时，使用std::bind函数还可以实现参数顺序调整等操作。
- 通常bind可以和function在一起用
使用
- bind，第一个参数传的是可调用对象
- placeholders
placeholders是一个命名空间，里面定义了很多_1,_2,_3等等，这些东西是一个占位对象。绑定后如果需要自己传参数，_1代表要传的第一个参数，_2代表要传的第二个参数
可以结合如下代码理解：
1.调整参数顺序
例如说调用银行的不同利率
double Plus(int a, int b, double rate)
{
return (a + b) * rate;
}
double PPlus(int a, double rate, int b)
{
return rate*(a + b);
}
int main()
{
function<double(int, int)> Plus1 = bind(Plus, placeholders::_1, placeholders::_2, 4.0);
function<double(int, int)> Plus2 = bind(Plus, placeholders::_1, placeholders::_2, 4.2);
function<double(int, int)> Plus3 = bind(Plus, placeholders::_1, placeholders::_2, 4.4);
cout << Plus1(5, 3) << endl;
cout << Plus2(5, 3) << endl;
cout << Plus3(5, 3) << endl;
//PPlus
function<double(int, int)> PPlus1 = bind(PPlus, placeholders::_1, 4.0, placeholders::_2);
function<double(int, int)> PPlus2 = bind(PPlus, placeholders::_1, 4.2, placeholders::_2);
cout << PPlus1(5, 3) << endl;
cout << PPlus2(5, 3) << endl;
}- 注意：对 PPlus 而言，是 _1,_2 不是 _2,_3
- 重申：_1代表要传的第一个参数，_2代表要传的第二个参数
- 打印：
2.对类中函数的包装方法
两种写法：
- Sub st;
bind(&Sub::sub,&st, ..) bind(&Sub::sub, Sub(), ..)
取函数地址后，再传个对象/对象的指针
class Sub
{
public:
int sub(int a, int b)
{
return a - b * x;
}
private:
int x = 20;
};
int main()
{
//绑定固定参数
//类成员函数多了一个参数，每次调用都需要在前面传一个对象然后才能调用
function<int(Sub, int, int)> func4 = &Sub::sub;
cout << func4(Sub(), 10, 20) << endl;
function<int(int, int)> func5 = bind(&Sub::sub, Sub(), placeholders::_1, placeholders::_2);
cout << func5(10, 20) << endl;
return 0;
}Bind 此处的调用的内部：还是一个 operate()的仿函数，相当于对类函数的提取
sum:
function 是想对各种可调用对象函数指针、函数对象，lambda进行适配包装给一个统一的类型。
bind 是对可调用的对象的参数进行包装绑定，然后调整，绑死。
![[数据集][目标检测]机油泄漏检测数据集VOC+YOLO格式43张1类别](https://i-blog.csdnimg.cn/direct/5d6f12625ae54956b400a0d56d7d1ff5.png)
