universal reference vs const reference priority?

Question

When I consider the two following overloads:

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

I have the guarantee that f(x) will always call the second function and will never lead to an ambiguity. In a sense the second version is universally prioritized compared to the first one for one argument whatever its type is.

Now consider the situation where there is a universal reference and a const reference versions of a function:

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

My question is: is their a universal priority between these two functions regardless of the type of x (r-value reference, reference, cv-qualifiers, pointer...) like in the previous case? (and if yes, what is the priority ?)

Odoacer

I think it was this talk that included this. – Raffinate

Answer 1

There is not a universal priority between these two functions. They compete equally in the overload resolution algorithm. In general the so-called "universal reference" wins unless const T& is an exact match, and there the const T& wins.

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
}

Good advice is to never overload like this.

Crib

It might be worth mentioning which of these cases (if any) #2 was never a candidate to begin with. – Milstone

@BenVoigt Unless I'm missing something, both overloads are viable in all these expressions. – Verger

@aschepler: I think you're right. Maybe it is T&& vs T& that ends up being surprising. – Milstone

Note the technical term "Exact Match" (13.3.3.1.1) applies to all twelve implicit conversion sequences. Might be safer to say "wins unless the argument is a const lvalue". – Verger

I'm not sure, but doesn't f(std::declval<const A&&>()); actually call f<const A>(const A&&)? – Tinkle