How do you pass boost::bind objects to a function?

倾然丶 夕夏残阳落幕 提交于 2019-12-10 01:48:03

问题


I have a one-dimensional function minimizer. Right now I'm passing it function pointers. However many functions have multiple parameters, some of which are held fixed. I have implemented this using functors like so

template <class T>
minimize(T &f) {
}

Functor f(param1, param2);
minimize<Functor>(f);

However the functor definition has lots of crud. Boost::bind looks cleaner. So that I could do:

minimize(boost:bind(f,_1,param1,param2))

However I'm not clear what my minimize declaration should like like using boost::bind. What type of object is boost::bind? Is there an easy pattern for this that avoids the boilerplate of functors but allows multiple parameter binding?


回答1:


You can just use boost::function. I think boost::bind does have its own return type, but that is compatible with boost::function. Typical use is to make a typedef for the function:

typedef boost::function<bool(std::string)> MyTestFunction;

and then you can pass any compatible function with boost::bind:

bool SomeFunction(int i, std::string s) { return true; }
MyTestFunction f = boost::bind(SomeFunction, 42, _1);
f("and then call it.");

I hope that is what you want.

It also works with methods by passing the this pointer for the call as second parameter to boost::bind.




回答2:


I would define minimize() this way:

minimize(boost::function< return_type(param_type1,param_type2,param_type3,...)> f)
{
    ...
}

Then you could call minimize() like this:

minimize(boost::bind(&class::function,actual_object,_1,_2,_3,...));



回答3:


Change the parameter to a value parameter. Function objects are intentionally light weight, and boost::bind certainly is, specially crafted to fit in within space of a few bytes using boost::compressed_pair and what not.

template <class T>
void minimize(T f) {
}

Then you can pass it the result of boost::bind. Remember that boost::bind is actually a function template that returns some object of some type. So having minimize have a non-const reference parameter couldn't work.




回答4:


First, you are taking your template argument as a ref-to-non-const, so the temporary returend by boost::bind won't bind to it. So you can use it like:

template <class T>
T::result_type minimize(const T &f) {
}

But if you wanted to use this with your Functors as well, they would have to have a const operator(). So perhaps by value is better:

 template <class T>
 T::result_type minimize(T f) {
 }

I believe having the return be T::result_type will force a T to be a boost::function (rather than the complicated type bind returns), but I'm not 100%



来源:https://stackoverflow.com/questions/1044703/how-do-you-pass-boostbind-objects-to-a-function

标签
易学教程内所有资源均来自网络或用户发布的内容,如有违反法律规定的内容欢迎反馈
该文章没有解决你所遇到的问题?点击提问,说说你的问题,让更多的人一起探讨吧!