[over.over] - C++23 → Trunk

Files changed (1) hide show

tmp/tmp_nszc5nz/{from.md → to.md} +40 -18

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

@@ -1,26 +1,28 @@
 ## Address of an overload set <a id="over.over">[[over.over]]</a>
-An *id-expression* whose terminal name refers to an overload set S and
-that appears without arguments is resolved to a function, a pointer to
-function, or a pointer to member function for a specific function that
-is chosen from a set of functions selected from S determined based on
-the target type required in the context (if any), as described below.
-The target can be
 - an object or reference being initialized
   [[dcl.init]], [[dcl.init.ref]], [[dcl.init.list]],
-- the left side of an assignment [[expr.ass]],
 - a parameter of a function [[expr.call]],
 - a parameter of a user-defined operator [[over.oper]],
 - the return value of a function, operator function, or conversion
   [[stmt.return]],
 - an explicit type conversion
   [[expr.type.conv]], [[expr.static.cast]], [[expr.cast]], or
-- a non-type *template-parameter* [[temp.arg.nontype]].
-The *id-expression* can be preceded by the `&` operator.
 [*Note 1*: Any redundant set of parentheses surrounding the function
 name is ignored [[expr.prim.paren]]. — *end note*]
 If there is no target, all non-template functions named are selected.
@@ -49,17 +51,17 @@ All functions with associated constraints that are not satisfied
 [[temp.constr.decl]] are eliminated from the set of selected functions.
 If more than one function in the set remains, all function template
 specializations in the set are eliminated if the set also contains a
 function that is not a function template specialization. Any given
 non-template function `F0` is eliminated if the set contains a second
-non-template function that is more constrained than `F0` according to
-the partial ordering rules of [[temp.constr.order]]. Any given function
-template specialization `F1` is eliminated if the set contains a second
-function template specialization whose function template is more
-specialized than the function template of `F1` according to the partial
-ordering rules of  [[temp.func.order]]. After such eliminations, if any,
-there shall remain exactly one selected function.
 [*Example 1*:
 ``` cpp
 int f(double);
@@ -73,12 +75,15 @@ void g() {
   (int (*)(int))&f;             // cast expression as selector
 }
 ```
 The initialization of `pfe` is ill-formed because no `f()` with type
-`int(...)` has been declared, and not because of any ambiguity. For
-another example,
 ``` cpp
 struct X {
   int f(int);
   static int f(long);
@@ -93,10 +98,27 @@ int (X::*p5)(int)  = &(X::f);   // error: wrong syntax for
 int    (*p6)(long) = &(X::f);   // OK
 ```
 — *end example*]
 [*Note 4*: If `f` and `g` are both overload sets, the Cartesian product
 of possibilities is considered to resolve `f(&g)`, or the equivalent
 expression `f(g)`. — *end note*]
 [*Note 5*:

 ## Address of an overload set <a id="over.over">[[over.over]]</a>
+An expression that designates an overload set S and that appears without
+arguments is resolved to a function, a pointer to function, or a pointer
+to member function for a specific function that is chosen from a set of
+functions selected from S determined based on the target type required
+in the context (if any), as described below. The target can be
 - an object or reference being initialized
   [[dcl.init]], [[dcl.init.ref]], [[dcl.init.list]],
+- the left side of an assignment [[expr.assign]],
 - a parameter of a function [[expr.call]],
 - a parameter of a user-defined operator [[over.oper]],
 - the return value of a function, operator function, or conversion
   [[stmt.return]],
 - an explicit type conversion
   [[expr.type.conv]], [[expr.static.cast]], [[expr.cast]], or
+- a constant template parameter [[temp.arg.nontype]].
+If the target type contains a placeholder type, placeholder type
+deduction is performed [[dcl.type.auto.deduct]], and the remainder of
+this subclause uses the target type so deduced. The expression can be
+preceded by the `&` operator.
 [*Note 1*: Any redundant set of parentheses surrounding the function
 name is ignored [[expr.prim.paren]]. — *end note*]
 If there is no target, all non-template functions named are selected.
 [[temp.constr.decl]] are eliminated from the set of selected functions.
 If more than one function in the set remains, all function template
 specializations in the set are eliminated if the set also contains a
 function that is not a function template specialization. Any given
 non-template function `F0` is eliminated if the set contains a second
+non-template function that is more partial-ordering-constrained than
+`F0` [[temp.constr.order]]. Any given function template specialization
+`F1` is eliminated if the set contains a second function template
+specialization whose function template is more specialized than the
+function template of `F1` according to the partial ordering rules of
+[[temp.func.order]]. After such eliminations, if any, there shall remain
+exactly one selected function.
 [*Example 1*:
 ``` cpp
 int f(double);
   (int (*)(int))&f;             // cast expression as selector
 }
 ```
 The initialization of `pfe` is ill-formed because no `f()` with type
+`int(...)` has been declared, and not because of any ambiguity.
+— *end example*]
+[*Example 2*:
 ``` cpp
 struct X {
   int f(int);
   static int f(long);
 int    (*p6)(long) = &(X::f);   // OK
 ```
 — *end example*]
+[*Example 3*:
+``` cpp
+template<bool B> struct X {
+  void f(short) requires B;
+  void f(long);
+  template<typename> void g(short) requires B;
+  template<typename> void g(long);
+};
+void test() {
+  &X<true>::f;                  // error: ambiguous; constraints are not considered
+  &X<true>::g<int>;             // error: ambiguous; constraints are not considered
+}
+```
+— *end example*]
 [*Note 4*: If `f` and `g` are both overload sets, the Cartesian product
 of possibilities is considered to resolve `f(&g)`, or the equivalent
 expression `f(g)`. — *end note*]
 [*Note 5*:

Diff to HTML by rtfpessoa