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 return type 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 return type 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 F1 is the same kind of reference (lvalue or rvalue) as the reference being initialized, and the return type of F2 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)
  F1 is not a function template specialization and F2 is a function template specialization, or, if not that,
• (2.5)
  F1 and F2 are function template specializations, and the function template for F1 is more specialized than the template for F2 according to the partial ordering rules described in [temp.func.order], or, if not that,
• (2.6)
  F1 and F2 are non-template functions and
  • (2.6.1)
    they have the same non-object-parameter-type-lists ([dcl.fct]), and
  • (2.6.2)
    if they are member functions, both are direct members of the same class, and
  • (2.6.3)
    if both are non-static member functions, they have the same types for their object parameters, and
  • (2.6.4)
    F1 is more constrained than F2 according to the partial ordering of constraints described in [temp.constr.order],
  or if not that,
  [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]
• (2.7)
  F1 is a constructor for a class D, F2 is a constructor for a base class B of D, and for all arguments the corresponding parameters of F1 and F2 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)
  F2 is a rewritten candidate ([over.match.oper]) and F1 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)
  F1 and F2 are rewritten candidates, and F2 is a synthesized candidate with reversed order of parameters and F1 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)
  F1 and F2 are generated from class template argument deduction ([over.match.class.deduct]) for a class D, and F2 is generated from inheriting constructors from a base class of D while F1 is not, and for each explicit function argument, the corresponding parameters of F1 and F2 are either both ellipses or have the same type, or, if not that,
• (2.11)
  F1 is generated from a deduction-guide ([over.match.class.deduct]) and F2 is not, or, if not that,
• (2.12)
  F1 is the copy deduction candidate and F2 is not, or, if not that,
• (2.13)
  F1 is generated from a non-template constructor and F2 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.111

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.