Utilizzo di std :: function/mem_fn in C++ 11 con funzioni membro

Question

Per farla breve, esiste un modo semplice/definito per trattare gli oggetti funzione/lambdas e le funzioni membro in modo semplificato?

Se ho capito bene, se uso std :: mem_fn, ho bisogno di passare un oggetto del tipo corretto per la chiamata di funzione, vale a dire

Object o; 
ftncall std::mem_fun(&Object::function); 
ftncall(o); 

Idealmente, ci sarebbe un modo per 'attaccare 'o per quell'oggetto funzione, forse come std::weak_ptr, quindi sappiamo se è stato cancellato. Ad esempio, se ci fosse un modo per fare qualcosa di vagamente simile a questo:

Object o; 
ftncall std::mem_fn(&Object::function, o); // Or maybe std::mem_fn<Object> 
ftncall(); 

Ora, ovviamente, questo non esiste (a mia conoscenza). C'è un modo per avvolgere std :: mem_fn in modo tale da non perdere la generalità (e la gentilezza) di std :: mem_fn, ma posso 'allegare' o, E giocare ancora bene con l'altro tipo di funzione, come std :: funzione? Idealmente, sarei ancora in grado di usare operator() nel modo in cui faccio con std :: function.

Attualmente la soluzione migliore che posso pensare è una classe che assomiglia a questo:

template<class T> 
class MemFunWrapper { 
public: 
    MemFunWrapper(T* t, std::mem_fun funct) : m_t(t), m_function(funct) {} 

    std::mem_fun operator*() { return m_function; } 
    T* get() { return m_t; } 
private: 
    T* m_t; 
    std::mem_fun m_function; 
} 

allora si potrebbe utilizzare questa convenzione:

(*MemFunWrapper)(MemFunWrapper->get(), args...); 

Ma che sembra abbastanza ingombrante per me. Inoltre, dovrei creare una classe equivalente per la funzione std :: per far sì che sia utilizzabile in modo analogo, e ciò sembra sciocco dal momento che posso già usare semplicemente std :: function. Idealmente, sarei anche in grado di utilizzare il prodotto finale senza sapere se sto chiamando una funzione membro o una funzione regolare. So che sto chiedendo molto - qualsiasi direzione sarebbe utile. Grazie molto!

Answer 1

Quello che stai cercando è std :: bind invece di std :: mem_fn:

#include <iostream> 
#include <functional> 

struct Object 
{ 
    void member() 
    { 
    std::cout << "yay!" << std::endl; 
    } 
}; 

int main() 
{ 
    Object o; 
    auto fn = std::bind(&Object::member, o); 
    fn(); 
} 

FWIW: C'è un proposal per l'aggiunta di un sovraccarico a std :: mem_fn accettare l'oggetto per l'inclusione in C++ 14.

Answer 2

In C++ 11, di solito trovo questo è più facile fatto con lambda:

std::shared_ptr<Object> o; 
auto ftncall = [o](){ if (o) o->function(); } 
ftncall(); 

Se avete bisogno di cancellazione del tipo, solo roba in una std::function<void()>.

Lambdas in C++ 11 può fare lo stesso lavoro di bind senza dover fare affidamento sulle funzioni di libreria per farlo, e personalmente le trovo molto più leggibili.

Ci sono alcune situazioni in cui bind può fare un lavoro migliore in C++ 11, ma sono casi d'angolo a questo punto (in C++ 1y, saranno tagliati anche più angoli).