¿Cómo se pasa boost :: bind objects a una función?

Question

Tengo un minimizador de función unidimensional. En este momento estoy pasando indicadores de función. Sin embargo, muchas funciones tienen múltiples parámetros, algunos de los cuales se mantienen fijos. Lo he implementado usando functors como

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

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

Sin embargo, la definición de functor tiene muchas crud. Boost :: bind se ve más limpio. Por lo que podía hacer:

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

Sin embargo no me queda claro lo que mi declaración minimize gustaría como el uso de boost::bind. ¿Qué tipo de objeto es boost::bind? ¿Existe un patrón fácil para esto que evite la repetición de los funtores, pero que permita la vinculación de múltiples parámetros?

Answer 1

Puede simplemente usar boost::function. Creo que boost::bind tiene su propio tipo de devolución, pero que es compatible con boost::function. El uso típico es hacer un typedef para la función:

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

y luego se puede pasar a cualquier función compatible con boost::bind:

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

espero que es lo que desea.

También funciona con métodos pasando el puntero this para la llamada como el segundo parámetro al boost::bind.

Answer 2

Yo definiría minimizar() de esta manera:

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

entonces se podría llamar a minimizar() así:

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

Answer 3

Cambie el parámetro a un valor de parámetro. Los objetos de función son intencionalmente livianos, y ciertamente boost::bind está hecho especialmente para caber dentro del espacio de algunos bytes usando boost::compressed_pair y lo que no.

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

Luego puede pasarlo por el resultado de boost::bind. Recuerde que boost::bind es en realidad una plantilla de función que devuelve algún objeto de algún tipo. Así que tener minimize tener un parámetro de referencia no const no podría funcionar.

Answer 4

En primer lugar, está tomando su argumento de plantilla como ref-to-non-const, por lo que el returend temporal de boost :: bind no se enlazará a él. Para que pueda usarlo como:

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

Pero si se quería utilizar esto con sus Functors así, tendrían que tener un operador const(). Así que tal vez por el valor, mejor:

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

Creo que teniendo el retorno sea T :: result_type obligará a una T para ser un :: función de refuerzo (en lugar de las complicadas declaraciones de tipo bind), pero no estoy 100%