Come passate boost :: legare oggetti a una funzione?

Question

Ho un minimizzatore di funzione unidimensionale. In questo momento sto passando a dei puntatori di funzione. Tuttavia molte funzioni hanno più parametri, alcuni dei quali sono mantenuti fissi. Ho implementato questo utilizzando funtori in questo modo

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

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

Tuttavia la definizione funtore ha un sacco di CRUD. Boost :: bind sembra più pulito. In modo che ho potuto fare:

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

Tuttavia io non sono chiare quello che la mia dichiarazione minimize piacerebbe come l'utilizzo di boost::bind. Che tipo di oggetto è boost::bind? Esiste un modello semplice per questo che evita il carattere standard dei funtori ma consente il collegamento di più parametri?

Answer 1

È possibile utilizzare semplicemente boost::function. Penso che boost::bind abbia il suo tipo di ritorno, ma quello è compatibile con boost::function. L'utilizzo tipico è quello di fare un typedef per la funzione:

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

e poi si può passare qualsiasi funzione compatibile con boost::bind:

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

spero che sia quello che vuoi.

Funziona anche con i metodi passando il puntatore this per la chiamata come secondo parametro a boost::bind.

Answer 2

mi definisco ridurre al minimo() in questo modo:

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

allora si potrebbe chiamare minimizzare() in questo modo:

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

Answer 3

Modificare il parametro su un parametro di valore. Gli oggetti funzione sono intenzionalmente leggeri, e lo è sicuramente lo boost::bind, creato appositamente per adattarsi nello spazio di pochi byte usando boost::compressed_pair e cosa no.

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

Quindi è possibile passare il risultato di boost::bind. Ricorda che boost::bind è in realtà un modello di funzione che restituisce alcuni oggetti di un certo tipo. Quindi avere minimize ha un parametro di riferimento non const non può funzionare.

Answer 4

In primo luogo, si sta prendendo l'argomento del modello come riferimento per non-const, quindi il ritorno temporaneo di boost :: bind non si associa ad esso. Così si può utilizzare come:

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

Ma se si volesse utilizzare questo con i vostri Funtori così, si dovrebbe avere un operatore di const(). Quindi, forse, per valore è migliore:

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

Credo che avendo il ritorno sia T :: result_type costringerà un T ad essere una funzione boost :: (piuttosto che le complicate rendimenti tipo di bind), ma io non sono 100%