Come utilizzare le funzioni lambda con boost::bind/std::bind in VC++ 2010?

Ho alcune funzioni lambda che si desidera associare utilizzando boost::bind o std::bind. (Non importa quale, purché funziona). Purtroppo entrambi mi danno diversi errori del compilatore:

auto f = [](){ cout<<"f()"<<endl; };
auto f2 = [](int x){ cout<<"f2() x="<<x<<endl; };

std::bind(f)(); //ok
std::bind(f2, 13)(); //error C2903: 'result' : symbol is neither a class template nor a function template

boost::bind(f)(); //error C2039: 'result_type' : is not a member of '`anonymous-namespace'::<lambda0>'
boost::bind(f2, 13)(); //error C2039: 'result_type' : is not a member of '`anonymous-namespace'::<lambda1>'

Quindi, qual è la soluzione più semplice per questo?

  • Perché vuoi usare bind ? Non è solo chiamata f() o f2(1) ?
  • Questo è naturalmente solo un esempio semplice, ma in realtà voglio memorizzare il bind risultato in funzione di oggetto.
  • Perché vuoi usare bind ? Ho pensato C++0x fornito chiusure ?
InformationsquelleAutor Timo | 2011-01-05



3 Replies
  1. 22

    È necessario specificare manualmente il tipo di ritorno:

    boost::bind<void>(f)();
    boost::bind<int>(f2, 13)();

    Si può anche scrivere voi stessi un modello di funzione di dedurre il tipo di ritorno automagicamente con Spinta.FunctionTypes a ispezionare la lambda operatore(), se non ti piace dica esplicitamente bind.

  2. 8
    std::function<void ()> f1 = [](){ std::cout<<"f1()"<<std::endl; };
    std::function<void (int)> f2 = [](int x){ std::cout<<"f2() x="<<x<<std::endl; };
    boost::function<void ()> f3 = [](){ std::cout<<"f3()"<<std::endl; };
    boost::function<void (int)> f4 = [](int x){ std::cout<<"f4() x="<<x<<std::endl; };
    
    //do you still wanna bind?
    std::bind(f1)(); //ok
    std::bind(f2, 13)(); //ok
    std::bind(f3)(); //ok
    std::bind(f4, 13)(); //ok
    
    //do you still wanna bind?
    boost::bind(f1)(); //ok
    boost::bind(f2, 13)(); //ok
    boost::bind(f3)(); //ok
    boost::bind(f4, 13)(); //ok
    • Solo se function introduce runtime-riferimento indiretto e bind è più veloce … È?
    • Mi viene il dubbio chiamando il funtore derivanti da associare sarebbe mai potuto essere più veloce, dato che la legano risultato aggiunge nella maggior parte dei casi ancora un altro livello di indirezione. associare sarà probabilmente richiesto in situazioni in cui alcuni parametri devono essere vincolato. Nell’esempio di cui sopra std::bind(f2, 13)(); lega il primo parametro il valore della costante di 13. Il risultato dell’associazione è un “funtore” che non accetta parametri e restituisce void.
    • Chiamando il risultato della bind potrebbe essere leggermente più veloce, poiché non c’è nessuna chiamata tramite una funzione virtuale come function.
    • Se si tenta di esso e debug si vedrà la stessa cosa succede in entrambi i casi. La differenza è che con legano la profondità di stack di chiamate fino all’effettivo lamda è chiamato è maggiore
    • Il mio commento precedente era per std::bind. Con boost::bind e boost::funzione di ciò che accade quando uno chiama il legato funtore o il boost::la funzione è davvero diverso e si potrebbe essere giusto potrebbe essere più veloce per chiamare sul bind risultato
    • Anche se nel mio test chiamando il boost::funzione direttamente è leggermente più chiamata a bind risultato (oltre 10000 chiamate).

Lascia un commento