universelle Referenz vs const Referenzpriorität?

Question

Wenn ich bedenke, die beiden folgenden Überlastungen:

template <class... T> void f(const T&... x); 
template <class T> void f(const T& x); 

ich die Garantie, dass f(x) wird die zweite Funktion jederzeit anrufen und wird nie zu einer Mehrdeutigkeit führen. In gewissem Sinne ist die zweite Version universell priorisiert im Vergleich zu der ersten für ein Argument, unabhängig von ihrem Typ.

Betrachten wir nun die Situation, wo es eine universelle Referenz und eine konstante Referenz Versionen einer Funktion:

template <class T> void f(T&& x); 
template <class T> void f(const T& x); 

Meine Frage ist: ist ihr eine universelle Priorität zwischen diesen beiden Funktionen unabhängig von der Art von x (R-Wert Referenz, Referenz, CV-Qualifier, Zeiger ...) wie im vorherigen Fall? (und wenn ja, was ist die Priorität?)

Answer 1

Zwischen diesen beiden Funktionen besteht keine universelle Priorität. Sie konkurrieren gleichermaßen im Überladungsauflösungsalgorithmus. Im Allgemeinen gewinnt die sogenannte "Universal Reference", es sei denn const T& ist eine exakte Übereinstimmung, und dort gewinnt die const T&.

struct A {}; 

int 
main() 
{ 
    f(std::declval<A>()); // calls f<A>(A&&), #1 
    f(std::declval<const A>()); // calls f<const A>(const A&&), #1 
    f(std::declval<A&>()); // calls f<A&>(A&), #1 
    f(std::declval<A&&>()); // calls f<A>(A&&), #1 
    f(std::declval<const A&&>()); // calls f<const A>(const A&&), #1 
    f(std::declval<const A&>()); // calls f<A>(const A&), #2 
} 

Guter Rat ist zu nie Überlastung wie diese.