一. std::bind
(一)std::bind实现的关键技术
【编程实验】探索bind原理,实现自己的bind函数
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
#include <iostream> #include <tuple> using namespace std; //1. 占位符定义 template<size_t idx> struct placeholder{}; template<size_t idx> using ph = placeholder<idx>; constexpr ph<0> _0{}; //定义一个constexpr类型的占位符对象(_0),并用大括号初始化。 constexpr ph<1> _1{}; //定义一个constexpr类型的占位符对象(_1) constexpr ph<2> _2; //定义一个constexpr类型的占位符对象(_2) constexpr ph<3> _3; //定义占位符对象(_3) //2. 参数选择:do_select_param会根据是否为占位符来选择合适的实参。 //2.2 泛化版本:arg不是占位符 template<class Args, class Params> struct do_select_param { decltype(auto) operator()(Args& arg, Params&&) //arg不是占位符,说明arg本身就是一个真正的实参,直接返回。 { return arg; //由于arg是个引用,decltype(auto)结果也是arg的引用 } }; //2.3 特化:arg为占位符情况。 template<size_t idx, class Params> struct do_select_param<placeholder<idx>, Params> //注意Params为bind返回的绑定对象被调用时,传入其中的参数包 { decltype(auto) operator()(placeholder<idx>, Params&& params) //这里的params是个tuple对象。 { return std::get<idx>(std::forward<Params>(params));//根据占位符取出params参数包中的实参。 } }; //2.1 根据占位符选择合适的实参 template<class Args, class Params> decltype(auto) select_param(Args& arg, Params&& params) { //注意,其中的arg是bind绑定时传入的实参,可能是实参或占位符。而params是bind返回的可调用对象被执行时传入的实参。 //如果绑定时是占位符,会do_select_param会分派到其特化的版本,否则分派到其泛化版本。 return do_select_param<Args, Params>{}(arg, std::move(params)); //params是副本,统一用move而不用forwared! } //3. binder类及辅助函数 //3.3 绑定对象(obj)的调用: 其中args表示传入bind函数的参数,params表示传入obj可调用对象的参数。 template<size_t... idx, class Callable, class Args, class Params> decltype(auto) bind_invoke(std::index_sequence<idx...>, Callable& obj, Args& args, Params&& params) { //根据args是否是占位符来选择合适的实参,并传给可调用对象obj。 //注意:为了提高效率,参数是以move的形式(右值)被传递给obj可调动对象的。 return std::invoke(obj, select_param(std::get<idx>(args), std::move(params))...);//C++17, invoke(func, 参数1, 参数2, ...) } //3.2 binder类(核心类) template<class Callable, class... Args> class binder { using Seq = std::index_sequence_for<Args...>; //等价于std::make_index_sequence<sizeof...(Args)> //会创建类似一个index_sequence<0,1,2...>的类 //保存bind函数的所有实参(即可调用对象及其实参) using args_t = std::tuple<std::decay_t<Args>...>; //注意,decay_t去掉其引用、const\volatile等特性) using callable_t = std::decay_t<Callable>; //可调用对象的类型(注意,decay_t去掉其引用、cv等特性) callable_t mObj; //以副本的形式保存可调用对象 args_t mArgs; //以副本的形式保存可调用对象的所有实参。(打包放在tuple中) public: //注意,不管是可调用对象(callableObj),还是它的实参(args)均会根据其左右值特性,被复制或移动到Binder类中,以副本的形式保存起来。 explicit binder(Callable&& callableObj, Args&& ... args) :mObj(std::forward<Callable>(callableObj)),mArgs(std::forward<Args>(args)...) { } //Binder仿函数的调用 template<class... Params> decltype(auto) operator()(Params&& ... params) //可调用对象被调用,并传入参数。 { //第1个参数:升序的整数序列。第4个参数将传入的params实参转化为tuple对象。 //注意:std::forward_as_tuple被定义成tuple<_Types&&...>(_STD forward<_Types>(_Args)...); // 这说明params将以引用的形式被保存在tuple中!!! return bind_invoke(Seq{}, mObj, mArgs, std::forward_as_tuple(std::forward<Params>(params)...)); } }; //3.1 bind辅助函数 template <class Callable, class... Args> decltype(auto) bind(Callable&& callableObj, Args&& ... args) { return binder<Callable, Args...>(std::forward<Callable>(callableObj), std::forward<Args>(args)...); } //测试函数 int add(int x, int y) { return x + y; } //测试类 class Test { public: int x; int add(int x, int y) { return x + y; } }; int main() { // 自定义bind函数的测试 auto f1 = bind(add, 1, 3); //add为函数名,会自动转为函数指针类型。 cout << f1() << endl; //4 auto f2 = bind(add, _0, _1); cout << f2(2, 3) << endl; //5 auto lam = [](int x, int y) {return x * y; }; auto f3 = bind(lam, _0, 3); cout << f3(3) << endl; //9 int a = 10; Test t1; auto f4 = bind(&Test::add, &t1, _0, _1); //add函数的第1个参数是this指针,因此需要将&t1传进去。同时注意add是成员函数, //需要用&来创建指向成员的函数指针。 cout << f4(a, 3) << endl; //13。 a和3都是以引用的形式传入“绑定对象”f4中。 t1.x = 100; auto f5 = bind(&Test::x, t1); //传入t1的副本 auto f6 = bind(&Test::x, std::ref(t1)); //传入t1的引用 t1.x = 200; cout << f5() << endl; //100 cout << f6() << endl; //200 return 0; }
1. 保存可调用对象及其形参
(1)保存可调用对象的实例:bind时会将可调用对象(如func)作为binder类的一个成员变量(如mObj)保存起来。
(2)保存形参:由于形参是变参,不能直接将变参作为成员变量。这里可用tuple将变参打包并保存起来(如mArgs)。
2. 可调用对象的执行
(1)将tuple展开为变参:绑定可调用对象时,是将可调用对象的形参(可能含占位符)保存在tuple中。到了调用阶段,就必须反过来将tuple展开为可变参数。因为这个可变参数才是可调用对象的形参。这里借助一个整型序列来将tuple变为可变参数,在展开tuple的过程中还需要根据占位符来选择合适实参,即占位符要替换为调用实参。
(2)根据占位符来选择合适的实参(如select_param函数)
①tuple中可能含有占位符,如果发现某个元素类型为占位符,则从调用时生成的实参tuple(如params)中取出相应的元素,用来作为变参的一个参数。如上面的select_param(ph<0>,{4,5,6}),ph<0>是个占位符,表示该处的实参是其后的{4,5,6}这个tuple中的0位置元素,即4。(具体的实现见do_select_param特化版本)
②如果某个类型不为占位符时,则直接从绑定时生成的形参tuple(如mArgs)中出取参数,用来作为变参的一个参数。如select_param(1,{4,5,6}),由于第1个实参为1,不是占位符,因此直接将1这个实参取出,传入invoke函数(具体实现见do_select_param泛化版本)
(二)注意事项
1.bind函数的所有实参(含第1个实参)都是按值传递的,即它们均通过复制或移动的方式以副本的形式保存起来的。可以通过对实参实施std::ref的方式来达到按引用存储的效果。
2.bind的返回值(称之为“绑定对象”)的所有实参都是按引用传递的,因为这些参数被打包成std::forward_as_tuple,而这里存的都是引用。【见binder的operator()函数】
3. 对于事先绑定的参数需要传具体的变量或值进去。对于不事先绑定的参数,需要传递占位符(如_1)进去。
4. 绑定类的成员函数时,需要用&来创建成员函数指针再将其作为实参传给bind的第1个实参,同时在bind的第2个实参中为该成员函数指定this指针,然后再传入该成员函数的其它参数。
二. 优先使用lambda而非bind
(一)lambda表达式具有更强的可读性,表达力更好。
(二)bind函数绑定重载函数时会遇到二义性问题。由于函数名只是个名字,不带形参类型等其他附加信息,所以无法知道被绑定的是哪个重载版本的函数。
(三)lambda表达式可能生成比使用std::bind运行效率更高的代码。编译器可能对函数名做inline函数调用,而不太可能对函数指针做这种优化。如setAlarm函数在lambda中的调用,可以被内联。但是std::bind绑定的是setAlarm函数指针而不是函数体本身,所以无法被内联。
(四)lambda的传参方式(按值还是按引用)比bind函数更直观。Lambda表达式的传参方式只需看其声明就可知。但使用bind需要牢记其工作原理,即bind在绑定时是按值传递实参的,绑定对象在调用时是按引用传递实参的。
(五)自C++14以后,std::bind己经彻底失败用武之地,可以完全被lambda替代。
三、bind使用的两种场合(C++11中)
(一)移动捕获:C++11中的lambda没有提供移动捕获特性,但可以通过std::bind和lambda表达式来模拟移动捕获(见《第18课 捕获机制及陷阱》)。而C++14中提供了初始化捕获的语言特性,从而消除了如此模拟的必要。
(二)多态函数对象:因为绑定对象的函数调用运算符利用了完美转发,它就可以接受任何类型的实参。当想要绑定的对象具有一个函数运算符模板时,是有利用价值的。但在C++14中,使用带有auto类型形参的lambda可以轻而易举地达成同样的效果。
【编程实验】lambda与bind的pk
#include <iostream> #include <functional> #include <chrono> using namespace std; using namespace std::chrono; //for steady_clock using namespace std::literals; //for 1h, 30s等 using namespace placeholders; //for _1、_2等。 using Time = std::chrono::steady_clock::time_point; //表示时刻的类型 using Duration = std::chrono::steady_clock::duration; //表示时长的类型 enum class Sound{Beep, Siren, Whistle}; //警报的声音类型(哔哔声、汽笛声、口哨声) enum class Volume{Normal, Loud, LoudPlusPlus}; //音量大小 //警报函数(3个形参) void setAlarm(Time t, Sound s, Duration d) //在t时刻,发出声音s,持续时长d { } //警报函数(4个形参) void setAlarm(Time t, Sound s, Duration d, Volume v) { } class Widget{}; enum class CompLevel{Low, Normal, High}; //压缩等级 Widget compress(const Widget& w, CompLevel lev) //制作w的压缩副本 { return Widget(); } class PolyWidget { public: template<typename T> void operator()(const T& param){} //仿函数可接受任何类型的形参对象,被称为多态函数对象! }; int main() { //1. lambda比bind可读性更强(下列between函数用于判断实参是否介于极小值和极大值之间) const auto lowVal = 0; const auto highVal = 100; //1.1使用lambda auto betweenL = [lowVal, highVal](const auto& val) //C++14 { return lowVal <= val && val <= highVal; }; //1.2 使用bind auto betweenB = std::bind(std::logical_and<>(), std::bind(std::less_equal<>(), lowVal, _1), std::bind(std::less_equal<>(), _1, highVal)); int x = 15, y = 150; cout << betweenL(x) << endl; //1 cout << betweenB(x) << endl; //1 cout << betweenL(y) << endl; //0 cout << betweenB(y) << endl; //0 //2. bind在延时求值、识别重载函数的使用方式繁琐。此外绑定函数时不会被内联到operator()中 //2.1 lambda表达式(C++14) auto setSoundL = [](Sound s) //setSoundL后面的L表达lambda表达式 { setAlarm(steady_clock::now() + 1h, s, 30s); //C++14支持1h、30s的写法。调用3个形参的setAlarm,不会发生二义性! //由于setAlarm是常规的函数调用,编译器会考虑将setAlarm内联到lambda中 }; setSoundL(Sound::Beep); //2.2 使用bind //2.2.1 错误的用法(警报启动时刻是在调用std::bind函数之后的1个小时) //auto setSoundB = std::bind(setAlarm, //setSoundB中的"B"表示bind // steady_clock::now() + 1h, //错误!该参数传给bind,而非setAlarm。意味着调用bind时时刻值己求出。但我们期望是setAlarm调用时对时刻求值。 // _1, //将传给setSoundB的第1个参数传到setAlarm的第2个参数中。此处bind无法知道该实参真正的类型,需向setAlaram查询! // 30s); //2.2.2 正确的用法(警报启动时刻是在调用setAlarm函数之后的1个小时) using SetAlarm3ParamType = void(*)(Time t, Sound s, Duration d); auto setSoundB = std::bind(static_cast<SetAlarm3ParamType>(setAlarm), //setAlarm是个函数名。没有形参信息,不知调用哪个重载版本的setAlarm,需强转! std::bind(std::plus<>(), std::bind(steady_clock::now), 1h), //延时求值,注意这里传入的是now这个函数,而不是now()的返回值! _1, 30s ); setSoundB(Sound::Beep); //由于bind参数中的setAlarm是个函数指针,故setSoundB的operator()中无法将setAlarm函数体本身内联进来。 //3. bind的传参方式不直观 Widget w; //3.1 在bind调用时的传参比较 auto compressRateB = std::bind(compress, w, _1); //bind时w被按值传递给绑定对象,是以副本形式被存储。(但这一点从bind的形参中看不出来,只有牢记其工 //作原理才能知道这个事实。 auto compressRateL = [w](CompLevel lev) {return compress(w, lev); }; //使用lambda时非常直观,w和lev都是以按值方式被传递给lambda表达式。 //3.2 在绑定对象被调用时传参的比较 compressRateB(CompLevel::High); //bind返回的绑定对象调用时,实参都是通过按引用传递的(这点也是要牢记bind工作原理才会知道的事实) compressRateL(CompLevel::High); //参数是以按值方式传递的。 //4. 多态函数对象 PolyWidget pw; //4.1 C++11中,bind的用途。绑定多态仿函数对象 auto pwB = std::bind(pw, _1); pwB(1930); //传入int pwB(nullptr); //传入nullptr pwB("SantaClaus"); //传入字符串字面量,pw.operator()中可以传入各种类型的对象。 //4.2 C++14中,可利用带auto形参的lambda来达到类似的效果 auto pwL = [&pw](const auto& param) { pw(param); }; pwL(1930); //传入int pwL(nullptr); //传入nullptr pwL("SantaClaus"); //传入字符串字面量,pw.operator()中可以传入各种类型的对象。 return 0; }