Come sovraccaricare su std: firma di funzione in C++

Question

So che questa domanda è stata posta prima, ma nonostante sia un programmatore esperto non capisco le risposte e non vedo modo di rispondere a queste domande precedenti per chiedere una precisazione. Non esiste un collegamento "risposta" o altro. Inoltre, quelle domande erano piuttosto vecchie. Quindi, sto facendo di nuovo la domanda.

Ho una classe, in cui sovraccarico l'operatore + =. Voglio un sovraccarico di prendere un puntatore a funzione nuda, e l'altro di prendere una std :: funzione:

void operator+=(void (*handler)()); 
void operator+=(function<void (void *, T)> handler); 

Usage:

MyClass a; 
a += [](){ DoSomething(); }; 
a += [](void *x, T y){ DoSomething(); }; 

Purtroppo, il codice non viene compilato perché il compilatore non è in grado di determinare che il secondo sovraccarico non è adatto per la prima + = chiamata.

Come definire il mio operatore + = funzioni membro per correggere questo problema? Non voglio cambiare il modo in cui vengono utilizzati gli operatori (ad esempio utilizzando un cast esplicito). Voglio che funzionino come dimostrato sopra.

Inoltre, sarebbe utile avere il seguente overload così:

void operator+=(function<void()> handler); 

Ma ancora una volta, non può sovraccaricare in base alla firma della funzione <> modello.

Vedere questo thread per ulteriori esempi: Isn't the template argument (the signature) of std::function part of its type? (ho provato attuazione delle diverse soluzioni menzionate in quel filo, e nessuno di essi compilazione)

Sono stato di programmazione per molti anni in numerosi lingue, ma le mie competenze in C++ sono un po 'arrugginite.

Answer 1

Seguendo codice funziona bene con g ++ 4.7.2:

#include <functional> 
#include <iostream> 

template <typename T> 
typename std::enable_if<std::is_convertible<T, void(*)()>::value>::type 
foo(T&&) 
{ 
    std::cout << "foo(void(*)())" << std::endl; 
} 

void foo(std::function<void(void*,int)>) 
{ 
    std::cout << "foo(std::function<void(void*,int)>)" << std::endl; 
} 

int main() 
{ 
    foo([]{}); 
    foo([](void*,int){}); 
} 

Il problema è causato dal costruttore di std::function, che viene dichiarato come template <class F> function(F);. Quel costruttore accetta tutto come argomento. Se questo argomento non ha uno operator() appropriato, viene generato un errore durante l'istanziazione del costruttore.

Sfortunatamente il processo di risoluzione del sovraccarico non richiede l'istanziazione di alcuna funzione modello, pertanto il compilatore ritiene che tutto possa essere convertito in qualsiasi tipo di std::function.

Answer 2

Ok, se hai un std::vector<std::function<void()>> non hai nemmeno bisogno di avere un sacco di sovraccarichi. Il modo più semplice è definire un modello operator+=, possibile "protetto" con std::enable_if da attivare solo per oggetto richiamabile o puntatori di funzione. Così passando lambda o puntatori grezzi farà la conversione automatica per te su assign (push_back/emplace_back). Il passaggio std::function assegnerà solo come previsto.