std :: function non riesce a distinguere le funzioni sovraccariche

Question

Sto cercando di capire perché std::function non è in grado di distinguere tra funzioni sovraccariche.

#include <functional> 

void add(int,int){} 

class A {}; 

void add (A, A){} 

int main(){ 
     std::function <void(int, int)> func = add; 
} 

Nel codice mostrato sopra, function<void(int, int)> può competere solo una di queste funzioni, eppure fallisce. Perché è così? So che posso aggirare questo problema usando una lambda o un puntatore a funzione della funzione effettiva e quindi memorizzando il puntatore funzione in funzione. Ma perché questo fallisce? Non è chiaro il contesto su quale funzione voglio essere scelta? Per favore aiutami a capire perché questo non funziona perché non sono in grado di capire perché la corrispondenza dei modelli fallisce in questo caso.

Gli errori del compilatore che ricevo su clang per questo sono i seguenti:

test.cpp:10:33: error: no viable conversion from '<overloaded function type>' to 
     'std::function<void (int, int)>' 
     std::function <void(int, int)> func = add; 
            ^ ~~~ 
/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/../include/c++/v1/__functional_03:1266:31: note: 
     candidate constructor not viable: no overload of 'add' matching 
     'std::__1::nullptr_t' for 1st argument 
    _LIBCPP_INLINE_VISIBILITY function(nullptr_t) : __f_(0) {} 
          ^
/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/../include/c++/v1/__functional_03:1267:5: note: 
     candidate constructor not viable: no overload of 'add' matching 'const 
     std::__1::function<void (int, int)> &' for 1st argument 
    function(const function&); 
    ^
/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/../include/c++/v1/__functional_03:1269:7: note: 
     candidate template ignored: couldn't infer template argument '_Fp' 
     function(_Fp, 
    ^
1 error generated. 

EDIT - Oltre alla risposta MSalters', ho fatto qualche ricerca su questo forum e ho trovato il motivo esatto per cui questo non riesce. Ho ricevuto la risposta dalla risposta di Nawaz in questo post.

ho copia incollato dalla sua risposta qui:

int test(const std::string&) { 
     return 0; 
    } 

    int test(const std::string*) { 
     return 0; 
    } 

    typedef int (*funtype)(const std::string&); 

    funtype fun = test; //no cast required now! 
    std::function<int(const std::string&)> func = fun; //no cast! 

Allora perché std::function<int(const std::string&)> non funziona il modo in cui funziona funtype fun = test di cui sopra?

Beh, la risposta è, perché std::function possono essere inizializzati con qualsiasi oggetto, come il suo costruttore è templatized che è indipendente dell'argomento modello è stato passato a std::function.

Answer 1

E 'ovvio per noi quale funzione si intende essere scelto, ma il compilatore deve seguire le regole del C++ non utilizzare salti intelligenti di logica (o anche non così intelligenti, come in casi semplici come questo!)

Il costruttore dedicata del std::function è:

template<class F> function(F f); 

che è un modello che accetta qualsiasi tipo.

Lo standard C++ 14 fa vincolare il modello (dal LWG DR 2132) in modo che:

non partecipa alla risoluzione di sovraccarico a meno f è invocabile (20.9.12.2) per tipi di argomento ArgTypes... e tipo di ritorno R.

il che significa che il compilatore consentire solo il costruttore da chiamare quando Functor è compatibile con la firma chiamata del std::function (che è void(int, int) nel tuo esempio). In teoria ciò dovrebbe significare che void add(A, A) non è un argomento valido e quindi "ovviamente" intendevi usare void add(int, int).

Tuttavia, il compilatore non può testare il "f è richiamabile per tipi di argomento ..." vincolo finché non conosce il tipo di f, che significa che deve già disambiguare tra void add(int, int) e void add(A, A)prima può applicare il vincolo che gli consentirebbe di rifiutare una di quelle funzioni!

Quindi c'è una situazione dell'uovo e della gallina, il che significa, purtroppo, che è necessario per aiutare il compilatore fuori specificando esattamente quali sovraccarico add che si desidera utilizzare, e poi il compilatore può applicare il vincolo e (piuttosto ridondante) decidere che è un argomento accettabile per il costruttore.

È concepibile che si possa cambiare C++ in modo che in casi come questo tutte le funzioni sovraccaricate sono testati contro il vincolo (in modo che non hanno bisogno di sapere quale testare prima del test) e se solo una è fattibile, quindi usa quello, ma non è così che funziona il C++.

Answer 2

Prova:

std::function <void(int, int)> func = static_cast<void(*)(int, int)> (add); 

indirizzi a void add(A, A) e void add(int, int) differes cosa volessero. Quando si punta alla funzione per nome, è praticamente impossibile per il compilatore sapere quale indirizzo di funzione è necessario. void(int, int) qui non è un suggerimento.

Answer 3

Mentre è ovvio ciò che si desidera, il problema è che std::function non può influenzare la risoluzione di sovraccarico di &add. Se dovessi inizializzare un puntatore a funzioni non elaborate (void (*func)(int,int) = &add), funziona. Questo perché l'inizializzazione del puntatore funzione è un contesto in cui viene eseguita la risoluzione di sovraccarico. Il tipo di target è esattamente conosciuto. Ma std::function prenderà quasi tutti gli argomenti che possono essere richiamati. Questa flessibilità nell'accettare argomenti significa che non è possibile eseguire la risoluzione di sovraccarico su &add. Potrebbero essere adatti sovraccarichi multipli di add.

Un cast esplicito funzionerà, ovvero static_cast<void(*)(int, int)> (&add).

questo può essere avvolto in un template<typename F> std::function<F> make_function(F*) che permetterebbe di scrivere auto func = make_function<int(int,int)> (&add)

Answer 4

Per quanto posso vedere, si tratta di un problema di Visual Studio.

C++ 11 normale (20.8.11)

std::function synopsis 
template<class R, class... ArgTypes> class function<R(ArgTypes...)>; 

ma VisualStudio non ha che la specializzazione

clang ++ e g ++ sono perfettamente bene con sovraccarico std :: funzioni

prima le risposte spiegano perché VS non funziona, ma non hanno menzionato che è il bug di VS

Answer 5

Un altro modo per affrontare questo è con un lambda generico in C++ 14:

int main() { 
    std::function <void(int, int)> func = [](auto &&... args) { add(std::forward<decltype(args)>(args)...); 
} 

Ciò creerà una funzione lambda che risolverà le cose senza ambiguità. Non inoltro argomenti,