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

Files changed (1) hide show

tmp/tmpubvanc6q/{from.md → to.md} +26 -32

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

@@ -1,25 +1,26 @@
-## Address of overloaded function <a id="over.over">[[over.over]]</a>
-A use of a function name 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 selected functions 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 function name 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.
@@ -28,30 +29,23 @@ function type `FT` of the target type if `F` (after possibly applying
 the function pointer conversion [[conv.fctptr]]) is identical to `FT`.
 [*Note 2*: That is, the class of which the function is a member is
 ignored when matching a pointer-to-member-function type. — *end note*]
-For each function template designated by the name, template argument
-deduction is done [[temp.deduct.funcaddr]], and if the argument
-deduction succeeds, the resulting template argument list is used to
-generate a single function template specialization, which is added to
-the set of selected functions considered.
-[*Note 3*: As described in  [[temp.arg.explicit]], if deduction fails
-and the function template name is followed by an explicit template
-argument list, the *template-id* is then examined to see whether it
-identifies a single function template specialization. If it does, the
-*template-id* is considered to be an lvalue for that function template
-specialization. The target type is not used in that
-determination. — *end note*]
-Non-member functions and static member functions match targets of
-function pointer type or reference to function type. Non-static member
-functions match targets of pointer-to-member-function type. If a
-non-static member function is selected, the reference to the overloaded
-function name is required to have the form of a pointer to member as
-described in  [[expr.unary.op]].
 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
@@ -99,13 +93,13 @@ 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 overloaded functions, the cross
-product of possibilities must be considered to resolve `f(&g)`, or the
-equivalent expression `f(g)`. — *end note*]
 [*Note 5*:
 Even if `B` is a public base of `D`, we have

+## 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.
 the function pointer conversion [[conv.fctptr]]) is identical to `FT`.
 [*Note 2*: That is, the class of which the function is a member is
 ignored when matching a pointer-to-member-function type. — *end note*]
+The specialization, if any, generated by template argument deduction
+[[temp.over]], [[temp.deduct.funcaddr]], [[temp.arg.explicit]] for each
+function template named is added to the set of selected functions
+considered.
+Non-member functions, static member functions, and explicit object
+member functions match targets of function pointer type or reference to
+function type. Implicit object member functions match targets of
+pointer-to-member-function type.
+[*Note 3*: If an implicit object member function is chosen, the result
+can be used only to form a pointer to member
+[[expr.unary.op]]. — *end note*]
 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
 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*:
 Even if `B` is a public base of `D`, we have

Diff to HTML by rtfpessoa