[over.match.call] - C++14 → C++17

Files changed (1) hide show

tmp/tmpau7_3ze4/{from.md → to.md} +29 -22

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

@@ -14,12 +14,13 @@ class type, overload resolution is applied as specified in
 If the *postfix-expression* denotes the address of a set of overloaded
 functions and/or function templates, overload resolution is applied
 using that set as described above. If the function selected by overload
 resolution is a non-static member function, the program is ill-formed.
-The resolution of the address of an overload set in other contexts is
-described in [[over.over]].
 ##### Call to named function <a id="over.call.func">[[over.call.func]]</a>
 Of interest in  [[over.call.func]] are only those function calls in
 which the *postfix-expression* ultimately contains a name that denotes
@@ -42,12 +43,12 @@ In qualified function calls, the name to be resolved is an
 construct `A->B` is generally equivalent to `(*A).B`, the rest of
 Clause  [[over]] assumes, without loss of generality, that all member
 function calls have been normalized to the form that uses an object and
 the `.` operator. Furthermore, Clause  [[over]] assumes that the
 *postfix-expression* that is the left operand of the `.` operator has
-type “*cv* `T`” where `T` denotes a class[^3]. Under this assumption,
-the *id-expression* in the call is looked up as a member function of `T`
 following the rules for looking up names in classes (
 [[class.member.lookup]]). The function declarations found by that lookup
 constitute the set of candidate functions. The argument list is the
 *expression-list* in the call augmented by the addition of the left
 operand of the `.` operator in the normalized member function call as
@@ -73,32 +74,33 @@ and overload resolution selects one of the non-static member functions
 of `T`, the call is ill-formed.
 ##### Call to object of class type <a id="over.call.object">[[over.call.object]]</a>
 If the *primary-expression* `E` in the function call syntax evaluates to
-a class object of type “*cv* `T`”, then the set of candidate functions
 includes at least the function call operators of `T`. The function call
 operators of `T` are obtained by ordinary lookup of the name
 `operator()` in the context of `(E).operator()`.
 In addition, for each non-explicit conversion function declared in `T`
 of the form
 ``` bnf
-'operator' conversion-type-id '( )' cv-qualifier ref-qualifierₒₚₜ exception-specificationₒₚₜ attribute-specifier-seqₒₚₜ ';'
 ```
 where *cv-qualifier* is the same cv-qualification as, or a greater
-cv-qualification than, *cv*, and where *conversion-type-id* denotes the
-type “pointer to function of (`P1`,...,`Pn)` returning `R`”, or the type
-“reference to pointer to function of (`P1`,...,`Pn)` returning `R`”, or
-the type “reference to function of (`P1`,...,`Pn)` returning `R`”, a
 *surrogate call function* with the unique name *call-function* and
 having the form
 ``` bnf
-'R' call-function '(' conversion-type-id 'F, P1 a1, ... ,Pn an)' '{ return F (a1,... ,an); }'
 ```
 is also considered as a candidate function. Similarly, surrogate call
 functions are added to the set of candidate functions for each
 non-explicit conversion function declared in a base class of `T`
@@ -112,28 +114,33 @@ then be invoked with the arguments of the call. If the conversion
 function cannot be called (e.g., because of an ambiguity), the program
 is ill-formed.
 The argument list submitted to overload resolution consists of the
 argument expressions present in the function call syntax preceded by the
-implied object argument `(E)`. When comparing the call against the
-function call operators, the implied object argument is compared against
-the implicit object parameter of the function call operator. When
-comparing the call against a surrogate call function, the implied object
-argument is compared against the first parameter of the surrogate call
-function. The conversion function from which the surrogate call function
-was derived will be used in the conversion sequence for that parameter
-since it converts the implied object argument to the appropriate
-function pointer or reference required by that first parameter.
 ``` cpp
 int f1(int);
 int f2(float);
 typedef int (*fp1)(int);
 typedef int (*fp2)(float);
 struct A {
   operator fp1() { return f1; }
   operator fp2() { return f2; }
 } a;
-int i = a(1); // calls f1 via pointer returned from
-                    // conversion function
 ```

 If the *postfix-expression* denotes the address of a set of overloaded
 functions and/or function templates, overload resolution is applied
 using that set as described above. If the function selected by overload
 resolution is a non-static member function, the program is ill-formed.
+[*Note 1*: The resolution of the address of an overload set in other
+contexts is described in [[over.over]]. — *end note*]
 ##### Call to named function <a id="over.call.func">[[over.call.func]]</a>
 Of interest in  [[over.call.func]] are only those function calls in
 which the *postfix-expression* ultimately contains a name that denotes
 construct `A->B` is generally equivalent to `(*A).B`, the rest of
 Clause  [[over]] assumes, without loss of generality, that all member
 function calls have been normalized to the form that uses an object and
 the `.` operator. Furthermore, Clause  [[over]] assumes that the
 *postfix-expression* that is the left operand of the `.` operator has
+type “cv `T`” where `T` denotes a class[^3]. Under this assumption, the
+*id-expression* in the call is looked up as a member function of `T`
 following the rules for looking up names in classes (
 [[class.member.lookup]]). The function declarations found by that lookup
 constitute the set of candidate functions. The argument list is the
 *expression-list* in the call augmented by the addition of the left
 operand of the `.` operator in the normalized member function call as
 of `T`, the call is ill-formed.
 ##### Call to object of class type <a id="over.call.object">[[over.call.object]]</a>
 If the *primary-expression* `E` in the function call syntax evaluates to
+a class object of type “cv `T`”, then the set of candidate functions
 includes at least the function call operators of `T`. The function call
 operators of `T` are obtained by ordinary lookup of the name
 `operator()` in the context of `(E).operator()`.
 In addition, for each non-explicit conversion function declared in `T`
 of the form
 ``` bnf
+'operator' conversion-type-id '( )' cv-qualifier ref-qualifierₒₚₜ noexcept-specifierₒₚₜ attribute-specifier-seqₒₚₜ ';'
 ```
 where *cv-qualifier* is the same cv-qualification as, or a greater
+cv-qualification than, cv, and where *conversion-type-id* denotes the
+type “pointer to function of (`P₁`, …, `Pₙ`) returning `R`”, or the type
+“reference to pointer to function of (`P₁`, …, `Pₙ`) returning `R`”, or
+the type “reference to function of (`P₁`, …, `Pₙ`) returning `R`”, a
 *surrogate call function* with the unique name *call-function* and
 having the form
 ``` bnf
+'R' call-function '(' conversion-type-id \ %
+'F, P₁ a₁, …, Pₙ aₙ)' '{ return F (a₁, …, aₙ); }'
 ```
 is also considered as a candidate function. Similarly, surrogate call
 functions are added to the set of candidate functions for each
 non-explicit conversion function declared in a base class of `T`
 function cannot be called (e.g., because of an ambiguity), the program
 is ill-formed.
 The argument list submitted to overload resolution consists of the
 argument expressions present in the function call syntax preceded by the
+implied object argument `(E)`.
+[*Note 2*: When comparing the call against the function call operators,
+the implied object argument is compared against the implicit object
+parameter of the function call operator. When comparing the call against
+a surrogate call function, the implied object argument is compared
+against the first parameter of the surrogate call function. The
+conversion function from which the surrogate call function was derived
+will be used in the conversion sequence for that parameter since it
+converts the implied object argument to the appropriate function pointer
+or reference required by that first parameter. — *end note*]
+[*Example 1*:
 ``` cpp
 int f1(int);
 int f2(float);
 typedef int (*fp1)(int);
 typedef int (*fp2)(float);
 struct A {
   operator fp1() { return f1; }
   operator fp2() { return f2; }
 } a;
+int i = a(1); // calls f1 via pointer returned from conversion function
 ```
+— *end example*]

Diff to HTML by rtfpessoa