référence universelle vs priorité de référence const?

Question

Quand je considère les deux suivants surcharges:

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

Je la garantie que f(x) appellera toujours la deuxième fonction et ne conduira jamais à une ambiguïté. En un sens, la deuxième version est prioritaire par rapport à la première pour un argument quel que soit son type.

considèrent maintenant la situation où il y a une référence universelle et une version de référence const d'une fonction:

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

Ma question est: est leur priorité universelle entre ces deux fonctions quel que soit le type de x (référence r-value, référence, cv-qualificateurs, pointeur ...) comme dans le cas précédent? (et si oui, quelle est la priorité?)

Answer 1

Il n'y a pas de priorité universelle entre ces deux fonctions. Ils rivalisent également dans l'algorithme de résolution de surcharge. En général, la soi-disant «référence universelle» gagne à moins que const T& soit un match exact, et là les victoires 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 
} 

Un bon conseil est de ne jamais surcharge comme ça.