risoluzione C++ sovraccarico con funzione di modello di riferimento universale, che non può essere cambiato

Question

Supponiamo da qualche parte nel mio codice è una funzione foo con un parametro di riferimento universale, che non posso cambiare:

template<typename T> 
auto foo(T&& t) { std::cout<<"general version"<<std::endl; } 

Ora voglio sovraccarico foo per una determinata classe A e assicurarsi che per ogni qualificatore e tipo di riferimento di A venga chiamato il sovraccarico. Per questo posso bruta forcely fornire un sovraccarico per tutte le qualifiche possibili (ignorare volatile per ora):

auto foo(A & a) { std::cout<<"A&"<<std::endl; } 
auto foo(A const& a) { std::cout<<"A const&"<<std::endl; } 
auto foo(A && a) { std::cout<<"A &&"<<std::endl; } 
auto foo(A const&& a) { std::cout<<"A const&&"<<std::endl; } 

Demo. Questo tuttavia scala molto male per ulteriori parametri.

alternativa, posso passare dal valore, che sembra catturare così tutti i casi precedenti:

auto foo(A a) { std::cout<<"A"<<std::endl; } 

Demo. Ora però è necessario copiare un oggetto di grandi dimensioni (- almeno in linea di principio).

C'è un modo elegante per risolvere questi problemi?

Ricordare che non è possibile modificare la funzione di riferimento universale, quindi SFINAE e simili non sono possibili.

Answer 1

Onestamente, penso che tu sia sfortunato qui. Gli approcci tipici falliscono tutti. You can do ...

SFINAE?

template <typename T> auto foo(T&&); 
template <typename T, 
      typename = only_if_is<T, A>> 
auto foo(T&&); 

foo(A{}); // error: ambiguous 

Scrivere una classe che prende un riferimento di l-or-rvalue?

template <typename T> lref_or_ref { ... }; 

template <typename T> auto foo(T&&); 
auto foo(lref_or_ref<A>); 

foo(A{}); // calls general, it's a better match 

Il meglio che si possa fare è introdurre una funzione di inoltro tramite un selettore:

template <int I> struct chooser : chooser<I - 1> { }; 
template <> struct chooser<0> { }; 

template <typename T> 
auto bar(T&& t, chooser<0>) { 
    // worst-option, general case 
    foo(std::forward<T>(t)); 
} 

template <typename T, 
      typename = only_if_is<T, A>> 
auto bar(T&& t, chooser<1>) { 
    // A-specific 
} 

template <typename T> 
auto bar(T&& t) { 
    bar(std::forward<T>(t), chooser<20>{}); 
} 

Ma voi hanno citato in a comment che questo non funziona neanche per te. Quindi immagino che la tua unica opzione sia: scrivere una proposta al comitato degli standard!

---

Fondamentalmente, c'è speranza! Se concetti ottiene adottate (buon punto, TartanLlama!):

template <typename T> 
    requires IsForwardRefTo<T, A> 
auto foo(T&& t) { 
    // since this is more constrained than the generic forwarding reference 
    // this one should be preferred for foo(A{}) 
}