目录
1.function包装器
1.1什么是函数包装器(function)？
1.2为啥使用函数包装器(function)？
2.bind包装器
2.1绑定普通函数和调整传参顺序
2.2绑定类成员函数
1.function包装器
头文件#include<functional>
1.1什么是函数包装器(function)？
function:是一个通用多态函数包装器，是一个类模板，可以容纳除了类成员函数指针之外的所有可调用对象，它可以用统一的方式处理函数、函数对象、函数指针，成员函数（静态和非静态）并允许保存和延迟它们的执行。
std::function可以取代函数指针的作用，因为它可以延迟函数的执行，特别适合作为回调函数使用。
template <class T> function; // undefined template <class Ret, class... Args> class function<Ret(Args...)>;
Ret：被包装的可调用对象的返回值类型。Args...：被包装的可调用对象的形参类型。
function:是一个通用多态函数包装器，是一个类模板，可以容纳除了类成员函数指针之外的所有可调用对象，它可以用统一的方式处理函数、函数对象、函数指针，成员函数（静态和非静态）并允许保存和延迟它们的执行。
std::function可以取代函数指针的作用，因为它可以延迟函数的执行，特别适合作为回调函数使用。
//function包装器 int Plus(int a, int b) { return a + b; } class Sub { public: int sub(int a, int b) { return a - b; } }; int main() { function<int(int, int)>funcPlus = Plus; function<int(Sub, int, int)> funcSub = &Sub::sub; }这个就是一个简单的函数包装器。
1.2为啥使用函数包装器(function)？
由于函数调用可以使用函数名、函数指针、函数对象或有名称的lambda表达式，可调用类型太丰富导致模板的效率极低。包装器用于解决效率低的问题。
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; //count:1 count:0025C140 5.555 // 函数对象 cout << useF(Functor(), 11.11) << endl; //count:1 count: 0025C144 3.70333 // lamber表达式 cout << useF([](double d)->double { return d / 4; }, 11.11) << endl; //count : 1 count: 0025C148 2.7775 return 0; }
在此源码(这份源码是我借用一位师兄的) 中发现useF实例化了三份并且每一个count地址都是不同的。
而C++11新出了函数包装器就可以对可调用对象进行包装，包括函数指针（函数名）、仿函数（函数对象）、lambda表达式、类的成员函数。
int f(int a, int b) { return a + b; } struct Functor { public: int operator()(int a, int b) { return a + b; } }; class Plus { public: static int plusi(int a, int b) { return a + b; } double plusd(double a, double b) { return a + b; } }; int main() { //1、包装函数指针（函数名） function<int(int, int)> func1 = f; cout << func1(1, 2) << endl; //2、包装仿函数（函数对象） function<int(int, int)> func2 = Functor(); cout << func2(1, 2) << endl; //3、包装lambda表达式 function<int(int, int)> func3 = [](int a, int b){return a + b; }; cout << func3(1, 2) << endl; //4、类的静态成员函数 //function<int(int, int)> func4 = Plus::plusi; function<int(int, int)> func4 = &Plus::plusi; //&可省略 cout << func4(1, 2) << endl; //5、类的非静态成员函数 function<double(Plus, double, double)> func5 = &Plus::plusd; //&不可省略 cout << func5(Plus(), 1.1, 2.2) << endl; return 0; }
- 取静态成员函数的地址可以不用取地址运算符“&”，但取非静态成员函数的地址必须使用取地址运算符“&”。
- 包装非静态的成员函数时需要注意，非静态成员函数的第一个参数是隐藏this指针，因此在包装时需要指明第一个形参的类型为类的类型。
就像上面的源码一样，我们在包装f()和fector函数是只需要传2个参数，但是在包装plusd()时就需要传递3个参数。
假设我现在利用包装器建立字符串和对应函数的映射关系，并放到map容器里头，此时就会出现问题了：成员函数会有三个参数，而我map容器里的value位置仅允许传两个参数，导致参数无法匹配：所以此时C++大神们就想出来了bind捆绑器。
2.bind包装器
- bind是一个标准库函数，定义在functional头文件中。可以将bind函数看作一个通用的函数适配器，它接受一个可调用对象，生成新的可调用对象来适应原对象的参数列表。
- bind将可调用对象与其参数一起进行绑定，绑定后的结果可以使用std::function保存。bind绑定完成后，返回一个函数对象，它内部保存了原可调用对象的拷贝，具有operator()，返回值类型被自动推导为原可调用对象的返回值类型。调用时，这个函数对象将把之前存储的参数转发给原可调用对象完成调用。
绑定函数参数：
template <class Fn, class... Args> /* unspecified */ bind (Fn&& fn, Args&&... args); 带返回类型 （2） template <class Ret, class Fn, class... Args> /* unspecified */ bind (Fn&& fn, Args&&... args);
fn：可调用对象。args...：要绑定的参数列表：值或占位符。调用bind的一般形式是：
auto newCallable=bind(callable,arg_list);
callable：需要包装的可调用对象。newCallable：生成的新的可调用对象。arg_list：逗号分隔的参数列表，对应给定的callable的参数。当调用newCallable时，newCallable会调用callable，并传给它arg_list中的参数。- arg_list中的参数可能包含形如_n的占位符，如_1,_2，代表了newCallable中相应位置的参数等等。
2.1绑定普通函数和调整传参顺序
第一个参数为要绑定的可调用对象，后跟参数列表（参数列表同可调用对象的参数列表匹配）。参数列表中可包含名字形如 _n （n为整数）的占位符，n表示生成的可调用对象中参数的位置。placeholders::_1和placeholders::_2，表示后续调用新生成的可调用对象时，传入的第一个参数传给placeholders::_1，传入的第二个参数传给placeholders::_2。占位符位于std::placeholders命名空间。
//bind捆绑器 int Add(int a, int b) { return a + b; } int main() { std::function<int(int)>func_Add2 = std::bind(Add, std::placeholders::_1, 5); //int result = func_add1(18); //等于18+5 cout << "func_Add2(18+5):" << func_Add2(18) << endl; //对参数重排序 using namespace std::placeholders; auto func_Add3 = std::bind(Add, _2, _1); //参数位置对换了 cout << "func_Add3(18,5):" << func_Add3(18,5) << endl; }其实在第一个绑定中std::bind(Add, std::placeholders::_1, 5)，我们把Plus函数的第二个参数固定绑定为5了，第一个定绑定参数没变，此时调用绑定后新生成的可调用对象时就只需要传入一个参数，它会将该值与5相加后的结果进行返回。
而第二个例子是把参数列表中的前两个参数的顺序给改变了，但是还是这两个数相加。这个不显，如果是两数相减就明显了。
2.2绑定类成员函数
bind绑定类成员函数时：
- 第一个参数表示对象的成员函数的指针。
- 第二个参数表示对象的地址。
struct Func { void Print_sum(int a, int b) { std::cout << a - b << '\n'; } int data = 10; }; int main() { Func tmp; auto f = std::bind(&Func::Print_sum, &tmp, 12, std::placeholders::_1); f(25); // -13 }注意：必须显示的指定&Func::Print_sum，因为编译器不会将对象的成员函数隐式转换成函数指针，所以必须在Func::Print_sum前添加&取地址符；使用对象成员函数的指针时，必须要知道该指针属于哪个对象，因此第二个参数为对象的地址 &tmp.
