[over.match.best.general] - C++20 → C++23

Files changed (1) hide show

tmp/tmp_9en3e_e/{from.md → to.md} +205 -0

tmp/tmp_9en3e_e/{from.md → to.md} RENAMED Viewed

	@@ -0,0 +1,205 @@

+#### General <a id="over.match.best.general">[[over.match.best.general]]</a>
+Define ICSⁱ(`F`) as the implicit conversion sequence that converts the
+iᵗʰ argument in the list to the type of the iᵗʰ 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 `F₁` is defined to be a
+*better* function than another viable function `F₂` if for all arguments
+i, ICSⁱ(`F₁`) is not a worse conversion sequence than ICSⁱ(`F₂`), and
+then
+- for some argument j, ICSʲ(`F₁`) is a better conversion sequence than
+  ICSʲ(`F₂`), or, if not that,
+- 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 `F₁` 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 `F₂` to the destination type
+  \[*Example 1*:
+  ``` cpp
+  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,
+- the context is an initialization by conversion function for direct
+  reference binding [[over.match.ref]] 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*:
+  ``` cpp
+  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,
+- `F1` is not a function template specialization and `F2` is a function
+  template specialization, or, if not that,
+- `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,
+- `F1` and `F2` are non-template functions with the same
+  parameter-type-lists, and `F1` is more constrained than `F2` according
+  to the partial ordering of constraints described in
+  [[temp.constr.order]], or if not that,
+- `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 3*:
+  ``` cpp
+  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,
+- `F2` is a rewritten candidate [[over.match.oper]] and `F1` is not
+  \[*Example 4*:
+  ``` cpp
+  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,
+- `F1` and `F2` are rewritten candidates, and `F2` is a synthesized
+  candidate with reversed order of parameters and `F1` is not
+  \[*Example 5*:
+  ``` cpp
+  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
+- `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,
+- `F1` is generated from a *deduction-guide* [[over.match.class.deduct]]
+  and `F2` is not, or, if not that,
+- `F1` is the copy deduction candidate [[over.match.class.deduct]] and
+  `F2` is not, or, if not that,
+- `F1` is generated from a non-template constructor and `F2` is
+  generated from a constructor template.
+  \[*Example 6*:
+  ``` cpp
+  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.[^7]
+[*Example 7*:
+``` cpp
+void Fcn(const int*,  short);
+void Fcn(int*, int);
+int i;
+short s = 0;
+void f() {
+  Fcn(&i, s);       // is ambiguous because &i → int* is better than &i → const int*
+                    // but s → short is also better than s → int
+  Fcn(&i, 1L);      // calls Fcn(int*, int), because &i → int* is better than &i → const int*
+                    // and 1L → short and 1L → int are indistinguishable
+  Fcn(&i, 'c');     // calls Fcn(int*, int), because &i → int* is better than &i → const int*
+                    // and 'c' → int is better than 'c' → short
+}
+```
+— *end example*]
+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.
+[*Example 8*:
+``` cpp
+namespace A {
+  extern "C" void f(int = 5);
+}
+namespace B {
+  extern "C" void f(int = 5);
+}
+using A::f;
+using B::f;
+void use() {
+  f(3);             // OK, default argument was not used for viability
+  f();              // error: found default argument twice
+}
+```
+— *end example*]

Diff to HTML by rtfpessoa