Utilizzo di oggetti generici std :: function con funzioni membro in una class

Per una class voglio memorizzare alcuni puntatori di funzioni alle funzioni membro della stessa class in una map memorizza gli oggetti std::function . Ma non riesco proprio all’inizio con questo codice:

 class Foo { public: void doSomething() {} void bindFunction() { // ERROR std::function f = &Foo::doSomething; } }; 

Ricevo l’ error C2064: term does not evaluate to a function taking 0 arguments xxcallobj error C2064: term does not evaluate to a function taking 0 arguments in xxcallobj combinato con alcuni strani errori di istanziazione del modello. Attualmente sto lavorando su Windows 8 con Visual Studio 2010/2011 e su Win 7 con VS10. L’errore deve essere basato su alcune strane regole C ++ che non seguo.

EDIT: io NON uso boost. Questo è C ++ 11 integrato nel compilatore MS.

Una funzione membro non statica deve essere chiamata con un object. Cioè, passa sempre implicitamente “questo” puntatore come argomento.

Poiché la tua firma std::function specifica che la tua funzione non accetta alcun argomento ( ), devi associare il primo (e il solo) argomento.

 std::function f = std::bind(&Foo::doSomething, this); 

Se si desidera associare una funzione ai parametri, è necessario specificare i segnaposto:

 using namespace std::placeholders; std::function f = std::bind(&Foo::doSomethingArgs, this, _1, _2); 

Oppure, se il compilatore supporta le lambda C ++ 11:

 std::function f = [=](int a, int b) { this->doSomethingArgs(a, b); } 

(Non ho un compilatore compatibile con C ++ 11 in questo momento , quindi non posso controllare questo.)

O hai bisogno

 std::function f = &Foo::doSomething; 

in modo che tu possa chiamarlo su qualsiasi istanza o devi associare un’istanza specifica, ad esempio this

 std::function f = std::bind(&Foo::doSomething, this); 

Se hai bisogno di memorizzare una funzione membro senza l’istanza della class, puoi fare qualcosa di simile a questo:

 class MyClass { public: void MemberFunc(int value) { //do something } }; // Store member function binding auto callable = std::mem_fn(&MyClass::MemberFunc); // Call with late supplied 'this' MyClass myInst; callable(&myInst, 123); 

Come sarebbe il tipo di archiviazione senza auto ? Qualcosa come questo:

 std::_Mem_fn_wrap callable 

È anche ansible passare questa memoria di funzione a un bind di funzioni standard

 std::function binding = std::bind(callable, &testA, std::placeholders::_1); binding(123); // Call 

Passate e note future: esisteva un’interfaccia più vecchia std :: mem_func , ma da allora è stata deprecata. Esiste una proposta, post C ++ 17, per rendere il puntatore alle funzioni membro richiamabile . Questo sarebbe molto gradito.