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

Question

Per una classe, desidero memorizzare alcuni puntatori di funzioni alle funzioni membro della stessa classe in uno map memorizzando oggetti std::function. Ma non riesco proprio all'inizio con questo codice:

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

ricevo error C2064: term does not evaluate to a function taking 0 arguments in xxcallobj combinato con alcuni errori istanziazione di template strani. 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.

MODIFICA: lo faccio NON aumento di utilizzo. Questo è C++ 11 integrato nel compilatore MS.

Answer 1

una funzione di membro non statico deve essere chiamato con un oggetto Cioè, passa sempre implicitamente "questo" puntatore come argomento.

Perché la tua firma std::function specifica che la funzione non richiede alcun argomento (<void(void)>), è necessario legano il primo (e l'unico) argomento.

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

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

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

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

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

(Non ho un compilatore compatibile con C++ 11 a portata di mano al momento, quindi non posso controllare questo.)

Answer 2

O avete bisogno

std::function<void(Foo*)> f = &Foo::doSomething; 

in modo che si può chiamare in qualsiasi istanza, o hai bisogno di impegnare una specifica istanza, ad esempio this

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

Answer 3

Se è necessario memorizzare una funzione membro senza l'istanza della classe, si può fare qualcosa di simile:

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); 

Quale sarebbe il tipo di archiviazione assomigliare senza auto? Qualcosa di simile a questo:

std::_Mem_fn_wrap<void,void (__cdecl TestA::*)(int),TestA,int> callable 

È inoltre possibile passare questo stoccaggio funzione per una funzione standard vincolante

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

passato e note future: Una vecchia interfaccia std :: mem_func esistito, ma da allora stato deprecato. Esiste una proposta, post C++ 17, per rendere pointer to member functions callable. Questo sarebbe molto gradito.