各位大佬好，我是落羽！一个坚持不断学习进步的学生。
如果您觉得我的文章还不错，欢迎多多互三分享交流，一起学习进步！
也欢迎关注我的blog主页: 落羽的落羽
一、function
1. 概念
上一篇文章我们学习了lambda表达式的用法。
std::function是 C++11 标准库在 <functional> 头文件中引入的一个通用、多态的函数包装器。它的本质是一个类模板，可以包装、存储、复制和调用任何可调用对象（函数指针、仿函数、lambda表达式、bind表达式等），存储的可调用对象被称为function的目标。function不含目标则为空，调用空function的目标会抛异常。
函数指针、仿函数、lambda表达式等可调用对象的类型各不相同，function可以统一类型，对他们进行包装，这样在很多地方就方便声明可调用对象的类型。
2. 用法
以上是function的原型，使用语法为：
#include <functional>
std::function<返回类型(参数类型1, 参数类型2, ...)> 包装器名称;
来看一段代码实例：
#include <iostream>
#include <functional>
using namespace std;
// 普通函数
int add(int a, int b)
{
return a + b;
}
// Lambda表达式
auto multiply = [](int a, int b) { return a * b; };
// 仿函数
struct Subtract
{
int operator()(int a, int b) const
{
return a - b;
}
};
int main()
{
// 声明一个function，他可以包装一个返回int，接受两个int参数的可调用对象
function<int(int, int)> func;
// 包装普通函数
func = add;
cout << "Add: " << func(10, 5) << endl; // 输出 15
// 包装 Lambda 表达式
func = multiply;
cout << "Multiply: " << func(10, 5) << endl; // 输出 50
// 包装仿函数对象
Subtract sub;
func = sub;
cout << "Subtract: " << func(10, 5) << endl; // 输出 5
// 甚至可以包装一个临时的Lambda
func = [](int a, int b) { return a / b; };
cout << "Divide: " << func(10, 5) <<std::endl; // 输出 2
return 0;
}
有一个特殊的点是，类的成员函数也可以被包装，但成员函数必须要指定类域并且前面加上&才能获取地址，静态成员函数可以不加&，但是为了方便记忆，建议成员函数都加上吧。这时还有一个问题，普通成员函数还有一个隐含的this指针，在类外包装时，也一定要显式写出this指针参数类型，即当前类的指针类型：
class Plus
{
public:
Plus(int n = 10)
:_n(n)
{}
static int plusi(int a, int b)
{
return a + b;
}
double plusd(double a, double b)
{
return (a + b) * _n;
}
private:
int _n;
};
int main()
{
function<int(int, int)> f = &Plus::plusi;
cout << f(1, 1) << endl; // 输出2
function<double(Plus*, double, double)> f1 = &Plus::plusd;
//调用时实例化出一个对象取地址传参即可，或者传对象也可以
Plus pd
cout << f1(&pd, 1.1, 1.1) << endl; // 输出22
/*function<double(Plus, double, double)> f1 = &Plus::plusd;
Plus pd
cout << f1(pd, 1.1, 1.1) << endl; */
return 0;
}
二、bind
1. 概念
std::bind是一个函数模板，也包含在<functional>中，是一个可调用对象的包装器，可以把他看做一个函数适配器，对接收的可调用对象处理后返回一个可调用对象。bind可以用来调整参数个数和参数顺序。
2. 用法
调用bind的一般形式为：auto newCallable = bind(callable, arg_list);其中newCallable本身是一个可调用对象，arg_list是一个用逗号分隔的参数列表，对应给定callable的参数。arg_list中的参数可能包含形如_n的占位符，n是一个正整数，它们占据了传递给newCallable的参数的位置。n表示生成的可调用对象的参数的位置：如_1为newCallable的第1个参数，_2为newCallable的第2个参数，_3为newCallable的第3个参数，以此类推，_1/_2/_3…这些占位符都在一个叫placeholders的命名空间中。
#include <functional>
using namespace placeholders;
int Sub(int a, int b)
{
return a - b;
}
int main()
{
// _1代表sub1的第一个参数，_2代表sub1的第二个参数。
// bind内写成_2, _1的顺序，意味sub1的第二个参数会传给Sub的第一个参数a，sub1的第一个参数会传给Sub的第二个参数b
auto sub1 = bind(Sub, _2, _1);
cout << Sub(1, 2) << endl;
cout << sub1(1, 2) << endl;
return 0;
}
这是只改变参数顺序的一般用法。
bind还有最常用的改变参数个数用法，这个用法一般是为了绑死某些参数，使之为一个固定值，使用时就不需要再传参：
#include <functional>
using namespace placeholders;
int Sub(int a, int b)
{
return a - b;
}
int main()
{
// _1代表sub2的第一个参数，100代表绑死Sub的第一个参数a，a的值固定为100了
// a的值固定了，传参时就不需要传给a，sub2的第一个参数就会传给Sub的第二个参数b
auto sub2 = bind(Sub, 100, _1);
cout << Sub(1, 2) << endl;
cout << sub2(1);
return 0;
}
再比如，刚才上面讲到function包装类成员函数时说到，使用包装后的对象时还需要传给this指针一个参数。有了bind就可以提前绑死这个参数，后续每次使用就不需要额外传了：
#include <functional>
using namespace placeholders;
class Plus
{
public:
Plus(int n = 10)
:_n(n)
{}
double plusd(double a, double b)
{
return (a + b) * _n;
}
private:
int _n;
};
int main()
{
function<double(double, double)> f = bind(&Plus::plusd, Plus(), _1, _2);
cout << f(1, 2) << endl;
return 0;
}
本篇完，感谢阅读。