可调用对象可以使用运算符进行调用的对象本质是能像函数一样使用的东西常见课调用对象函数指针仿函数lambda表达式我们能否使用统一的方式对其封装进行调用这时候就可以使用包装器function包装器function包装器也就function适配器function把所有可调用对象包装成统一类型方便后续的调用templateclass 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; // lambda表达式 cout useF([](double d)-double { return d / 4; }, 11.11) endl; return 0; }思考每次打印的count地址相同吗原因函数指针仿函数lambda表达式是不同的类型不同的类型调用函数模板时会实例出不同的函数所以count在不同的函数中地址不同为了统一可调用对象的类型function出现std::function在头文件functional// 类模板原型如下 template class T function; // undefined template class Ret, class... Args class functionRet(Args...);使用方式//第一个double为返回类型里面的double为需要的参数 functiondouble(double) f1 f; coutf1(1.2)endl; functiondouble(double) f2 Functor(); coutf2(2.2)endl; functiondouble(double) f3 [](double d)-double { return d / 4; }; coutf3(3.3)endl;包装器解决了可调用对象的类型问题既然统一了类型就可以放到容器里面方便统一处理运用vectorfunctiondouble(double) arr1 { f1,f2,f3 }; vectorfunctiondouble(double) arr2 { f,Functor(),[](double d)-double { return d / 4; } }; double n 1.0; for (auto e : arr2) { cout e(n) endl; }对于类成员函数class Plus { public: double plus1(double a, double b) { return a b; } static int plus2(int a, int b) { return a b; } }; int main() { functiondouble(Plus,double, double) f1 Plus::plus1; functionint(int, int) f2 Plus::plus2; Plus p; cout f1(p, 1.1, 2.2) endl;; cout f2(2, 3) endl; return 0; }绑定类成员函数首先告诉编译器是哪个类域中的函数且需要获取函数的指针对于类的非静态函数需要在第一个参数的传入类名代表该位置要传this指针原因类的非静态函数来说第一个参数为隐藏的this指针但是在包装器对象调用时我们并没有直接传类对象的地址原因在于std::function会自动把对象转化为this指针不用手动取p。对于类的静态函数不需要传this指针因为类的静态函数是属于整个类的而非单个对象对其进行包装后直接调用即可templateclass 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() { functiondouble(double) f1 f; functiondouble(double) f2 Functor(); functiondouble(double) f3 [](double d)-double { return d / 4; }; useF(f1, 1.1); useF(f2, 2.1); useF(f3, 3.1); return 0; }最后来看上面的场景通过包装后包装器对象掉泪函数模板函数中count的地址是同一份地址说明类型相同bindbind是一个函数模板它就像一个函数包装器接收一个可调用对象生成一个新的可调用对象来适应元对象的参数列表通俗一点来讲就是bind就是提前给函数绑定参数一般而言对于一个原本接收N个参数的函数我们可以通过绑定一些参数返回一个接收M个参数的新函数同时bind也可以通过绑定实现参数顺序的调整// 原型如下 template class Fn, class... Args bind (Fn fn, Args... args); template class Ret, class Fn, class... Args bind (Fn fn, Args... args);bind的一般形式auto newCallablebind(callable,arg_list);int sub(int a, int b) { return a - b; } int main() { functionint(int, int) sub1 bind(sub, placeholders::_1, placeholders::_2); cout sub1(2, 1) endl; //交换参数顺序 functionint(int, int) sub2 bind(sub, placeholders::_2, placeholders::_1); cout sub2(2, 1); return 0; }第二张图表明bind将第一个参数绑定到形参的第二个位置将第二个参数绑定到形参的第一个个位置实现了参数的交换补充placeholders是一个命名空间内部定义了第几个形参_1指第一个形参_2指第二个参数等等一些场景中我们希望对于函数中的形参绑定一些确定的值满足我们的一些需求这时我们可以使用缺省参数来对形参进行绑定一些值但是这个绑定之后就不能修改了这个时候我们就可是使用bind来对形参进行绑定绑定出来的可调用对象是独立的可调用对象之间绑定的值互不影响double getRate(double a, double b, double rate) { return (a b) * rate; } int main() { functiondouble(double, double) f1 bind(getRate, placeholders::_1, placeholders::_2, 4.0); functiondouble(double, double) f2 bind(getRate, placeholders::_1, placeholders::_2, 5.1); cout f1(2, 3) endl; coutf2(2,3)endl; return 0; }同时注意需要绑定的值无论在形参的什么位置都不参与形参的顺序。不影响placeholders的参数的顺序对于类成员函数的绑定class SubType { public: static int sub(int a, int b) { return a - b; } int ssub(int a, int b, int rate) { return (a - b) * rate; } }; int main() { functionint(int, int) f1 bind(SubType::sub, placeholders::_1, placeholders::_2); functionint(int, int) f2 bind(SubType::ssub, SubType(),placeholders::_1, placeholders::_2,3); SubType s; functionint(int, int) f3 bind(SubType::ssub, s, placeholders::_1, placeholders::_2, 3); functionint(int, int) f4 bind(SubType::ssub, s, placeholders::_1, placeholders::_2, 3); cout f1(2, 1)endl; cout f2(2, 1) endl; return 0; }绑定类成员函数首先要告诉编译器是哪个类域里面的函数且需要获取函数的指针对于非静态函数还需要获取对象或其地址方便底层的调用且其类成员函数参数隐藏this指针