12 Overloading [over]

Define ${\text{ICS}}^i\left(\text{F}\right)$ as the implicit conversion sequence that converts the $i^{\text{th}}$ argument in the list to the type of the $i^{\text{th}}$ parameter of viable function F.

[over.best.ics] defines the implicit conversion sequences and [over.ics.rank] defines what it means for one implicit conversion sequence to be a better conversion sequence or worse conversion sequence than another.

Given these definitions, a viable function ${\text{F}}_1$ is defined to be a better function than another viable function ${\text{F}}_2$ if for all arguments i, ${\text{ICS}}^i\left({\text{F}}_1\right)$ is not a worse conversion sequence than ${\text{ICS}}^i\left({\text{F}}_2\right)$, and then

• (2.1)
  for some argument j, ${\text{ICS}}^j\left({\text{F}}_1\right)$ is a better conversion sequence than ${\text{ICS}}^j\left({\text{F}}_2\right)$, or, if not that,
• (2.2)
  the context is an initialization by user-defined conversion (see [dcl.init], [over.match.conv], and [over.match.ref]) and the standard conversion sequence from the result of ${\text{F}}_1$ to the destination type (i.e., the type of the entity being initialized) is a better conversion sequence than the standard conversion sequence from the result of ${\text{F}}_2$ to the destination type
  [Example 1: struct A { A(); operator int(); operator double(); } a; int i = a; // a.operator int() followed by no conversion is better than // a.operator double() followed by a conversion to int float x = a; // ambiguous: both possibilities require conversions, // and neither is better than the other — end example]
  or, if not that,
• (2.3)
  the context is an initialization by conversion function for direct reference binding of a reference to function type, the return type of ${\text{F}}_1$ is the same kind of reference (lvalue or rvalue) as the reference being initialized, and the return type of ${\text{F}}_2$ is not
  [Example 2: template <class T> struct A { operator T&(); // #1 operator T&&(); // #2 }; typedef int Fn(); A<Fn> a; Fn& lf = a; // calls #1 Fn&& rf = a; // calls #2 — end example]
  or, if not that,
• (2.4)
  ${\text{F}}_1$ is not a function template specialization and ${\text{F}}_2$ is a function template specialization, or, if not that,
• (2.5)
  ${\text{F}}_1$ and ${\text{F}}_2$ are function template specializations, and the function template for ${\text{F}}_1$ is more specialized than the template for ${\text{F}}_2$ according to the partial ordering rules described in [temp.func.order], or, if not that,
• (2.6)
  ${\text{F}}_1$ and ${\text{F}}_2$ are non-template functions and ${\text{F}}_1$ is more partial-ordering-constrained than ${\text{F}}_2$ ([temp.constr.order])
  [Example 3: template <typename T = int> struct S { constexpr void f(); // #1 constexpr void f(this S&) requires true; // #2 }; void test() { S<> s; s.f(); // calls #2 } — end example]
  or, if not that,
• (2.7)
  ${\text{F}}_1$ is a constructor for a class D, ${\text{F}}_2$ is a constructor for a base class B of D, and for all arguments the corresponding parameters of ${\text{F}}_1$ and ${\text{F}}_2$ have the same type
  [Example 4: struct A { A(int = 0); }; struct B: A { using A::A; B(); }; int main() { B b; // OK, B​::​B() } — end example]
  or, if not that,
• (2.8)
  ${\text{F}}_2$ is a rewritten candidate ([over.match.oper]) and ${\text{F}}_1$ is not
  [Example 5: struct S { friend auto operator<=>(const S&, const S&) = default; // #1 friend bool operator<(const S&, const S&); // #2 }; bool b = S() < S(); // calls #2 — end example]
  or, if not that,
• (2.9)
  ${\text{F}}_1$ and ${\text{F}}_2$ are rewritten candidates, and ${\text{F}}_2$ is a synthesized candidate with reversed order of parameters and ${\text{F}}_1$ is not
  [Example 6: struct S { friend std::weak_ordering operator<=>(const S&, int); // #1 friend std::weak_ordering operator<=>(int, const S&); // #2 }; bool b = 1 < S(); // calls #2 — end example]
  or, if not that,
• (2.10)
  ${\text{F}}_1$ and ${\text{F}}_2$ are generated from class template argument deduction ([over.match.class.deduct]) for a class D, and ${\text{F}}_2$ is generated from inheriting constructors from a base class of D while ${\text{F}}_1$ is not, and for each explicit function argument, the corresponding parameters of ${\text{F}}_1$ and ${\text{F}}_2$ are either both ellipses or have the same type, or, if not that,
• (2.11)
  ${\text{F}}_1$ is generated from a deduction-guide ([over.match.class.deduct]) and ${\text{F}}_2$ is not, or, if not that,
• (2.12)
  ${\text{F}}_1$ is the copy deduction candidate and ${\text{F}}_2$ is not, or, if not that,
• (2.13)
  ${\text{F}}_1$ is generated from a non-template constructor and ${\text{F}}_2$ is generated from a constructor template.
  [Example 7: template <class T> struct A { using value_type = T; A(value_type); // #1 A(const A&); // #2 A(T, T, int); // #3 template<class U> A(int, T, U); // #4 // #5 is the copy deduction candidate, A(A) }; A x(1, 2, 3); // uses #3, generated from a non-template constructor template <class T> A(T) -> A<T>; // #6, less specialized than #5 A a(42); // uses #6 to deduce A<int> and #1 to initialize A b = a; // uses #5 to deduce A<int> and #2 to initialize template <class T> A(A<T>) -> A<A<T>>; // #7, as specialized as #5 A b2 = a; // uses #7 to deduce A<A<int>> and #1 to initialize — end example]

If there is exactly one viable function that is a better function than all other viable functions, then it is the one selected by overload resolution; otherwise the call is ill-formed.105

If the best viable function resolves to a function for which multiple declarations were found, and if any two of these declarations inhabit different scopes and specify a default argument that made the function viable, the program is ill-formed.