[over.match.funcs] - C++11 → C++14

Files changed (1) hide show

tmp/tmpi5pwq77g/{from.md → to.md} +57 -29

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

@@ -92,10 +92,14 @@ handled as candidate functions in the usual way.[^2] A given name can
 refer to one or more function templates and also to a set of overloaded
 non-template functions. In such a case, the candidate functions
 generated from each function template are combined with the set of
 non-template candidate functions.
 #### Function call syntax <a id="over.match.call">[[over.match.call]]</a>
 In a function call ([[expr.call]])
 ``` bnf
@@ -178,11 +182,11 @@ operators of `T` are obtained by ordinary lookup of the name
 In addition, for each non-explicit conversion function declared in `T`
 of the form
 ``` bnf
-'operator' conversion-type-id '( )' attribute-specifier-seqₒₚₜ cv-qualifier ';'
 ```
 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
@@ -252,13 +256,13 @@ struct String {
 };
 String operator + (const String&, const String&);
 void f(void) {
  const char* p= "one" + "two";  // ill-formed because neither
-                                // operand has user-defined type
  int I = 1 + 1;                 // Always evaluates to 2 even if
-                                // user-defined types exist which
                                 // would perform the operation.
 }
 ```
 If either operand has a type that is a class or an enumeration, a
@@ -289,13 +293,14 @@ version is `T1`, and for a binary operator `@` with a left operand of a
 type whose cv-unqualified version is `T1` and a right operand of a type
 whose cv-unqualified version is `T2`, three sets of candidate functions,
 designated *member candidates*, *non-member candidates* and *built-in
 candidates*, are constructed as follows:
-- If `T1` is a complete class type, the set of member candidates is the
-  result of the qualified lookup of `T1::operator@` (
-  [[over.call.func]]); otherwise, the set of member candidates is empty.
 - The set of non-member candidates is the result of the unqualified
   lookup of `operator@` in the context of the expression according to
   the usual rules for name lookup in unqualified function calls (
   [[basic.lookup.argdep]]) except that all member functions are ignored.
   However, if no operand has a class type, only those non-member
@@ -310,12 +315,12 @@ candidates*, are constructed as follows:
   defined in  [[over.built]] that, compared to the given operator,
   - have the same operator name, and
   - accept the same number of operands, and
   - accept operand types to which the given operand or operands can be
     converted according to [[over.best.ics]], and
-  - do not have the same parameter-type-list as any non-template
- non-member candidate.
 For the built-in assignment operators, conversions of the left operand
 are restricted as follows:
 - no temporaries are introduced to hold the left operand, and
@@ -341,15 +346,30 @@ void m() {
   a + b;            // operator+(a,b) chosen over int(a) + int(b)
 }
 ```
 If a built-in candidate is selected by overload resolution, the operands
-are converted to the types of the corresponding parameters of the
-selected operation function. Then the operator is treated as the
 corresponding built-in operator and interpreted according to Clause
 [[expr]].
 The second operand of operator `->` is ignored in selecting an
 `operator->` function, and is not an argument when the `operator->`
 function is called. When `operator->` returns, the operator `->` is
 applied to the value returned, with the original second operand.[^7]
@@ -394,29 +414,32 @@ the candidate functions are all the converting constructors (
 Under the conditions specified in  [[dcl.init]], as part of a
 copy-initialization of an object of class type, a user-defined
 conversion can be invoked to convert an initializer expression to the
 type of the object being initialized. Overload resolution is used to
-select the user-defined conversion to be invoked. Assuming that “*cv1*
-`T`” is the type of the object being initialized, with `T` a class type,
-the candidate functions are selected as follows:
 - The converting constructors ([[class.conv.ctor]]) of `T` are
   candidate functions.
 - When the type of the initializer expression is a class type “*cv*
   `S`”, the non-explicit conversion functions of `S` and its base
   classes are considered. When initializing a temporary to be bound to
   the first parameter of a constructor that takes a reference to
   possibly cv-qualified `T` as its first argument, called with a single
-  argument in the context of direct-initialization, explicit conversion
-  functions are also considered. Those that are not hidden within `S`
-  and yield a type whose cv-unqualified version is the same type as `T`
-  or is a derived class thereof are candidate functions. Conversion
-  functions that return “reference to `X`” return lvalues or xvalues,
-  depending on the type of reference, of type `X` and are therefore
-  considered to yield `X` for this process of selecting candidate
-  functions.
 In both cases, the argument list has one argument, which is the
 initializer expression. This argument will be compared against the first
 parameter of the constructors and against the implicit object parameter
 of the conversion functions.
@@ -459,18 +482,23 @@ applying a conversion function to an initializer expression. Overload
 resolution is used to select the conversion function to be invoked.
 Assuming that “*cv1* `T`” is the underlying type of the reference being
 initialized, and “*cv* `S`” is the type of the initializer expression,
 with `S` a class type, the candidate functions are selected as follows:
-- The conversion functions of `S` and its base classes are considered,
- except that for copy-initialization, only the non-explicit conversion
- functions are considered. Those that are not hidden within `S` and
- yield type “lvalue reference to *cv2* `T2`” (when [[dcl.init.ref]]
- requires an lvalue result) or “ `T2`” or “rvalue reference to `T2`”
- (when [[dcl.init.ref]] requires an rvalue result), where “*cv1* `T`”
- is reference-compatible ([[dcl.init.ref]]) with “*cv2* `T2`”, are
-  candidate functions.
 The argument list has one argument, which is the initializer expression.
 This argument will be compared against the implicit object parameter of
 the conversion functions.

 refer to one or more function templates and also to a set of overloaded
 non-template functions. In such a case, the candidate functions
 generated from each function template are combined with the set of
 non-template candidate functions.
+A defaulted move constructor or assignment operator ([[class.copy]])
+that is defined as deleted is excluded from the set of candidate
+functions in all contexts.
 #### Function call syntax <a id="over.match.call">[[over.match.call]]</a>
 In a function call ([[expr.call]])
 ``` bnf
 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
 };
 String operator + (const String&, const String&);
 void f(void) {
  const char* p= "one" + "two";  // ill-formed because neither
+                                // operand has class or enumeration type
  int I = 1 + 1;                 // Always evaluates to 2 even if
+                                // class or enumeration types exist that
                                 // would perform the operation.
 }
 ```
 If either operand has a type that is a class or an enumeration, a
 type whose cv-unqualified version is `T1` and a right operand of a type
 whose cv-unqualified version is `T2`, three sets of candidate functions,
 designated *member candidates*, *non-member candidates* and *built-in
 candidates*, are constructed as follows:
+- If `T1` is a complete class type or a class currently being defined,
+ the set of member candidates is the result of the qualified lookup of
+ `T1::operator@` ([[over.call.func]]); otherwise, the set of member
+  candidates is empty.
 - The set of non-member candidates is the result of the unqualified
   lookup of `operator@` in the context of the expression according to
   the usual rules for name lookup in unqualified function calls (
   [[basic.lookup.argdep]]) except that all member functions are ignored.
   However, if no operand has a class type, only those non-member
   defined in  [[over.built]] that, compared to the given operator,
   - have the same operator name, and
   - accept the same number of operands, and
   - accept operand types to which the given operand or operands can be
     converted according to [[over.best.ics]], and
+  - do not have the same parameter-type-list as any non-member candidate
+ that is not a function template specialization.
 For the built-in assignment operators, conversions of the left operand
 are restricted as follows:
 - no temporaries are introduced to hold the left operand, and
   a + b;            // operator+(a,b) chosen over int(a) + int(b)
 }
 ```
 If a built-in candidate is selected by overload resolution, the operands
+of class type are converted to the types of the corresponding parameters
+of the selected operation function, except that the second standard
+conversion sequence of a user-defined conversion sequence (
+[[over.ics.user]]) is not applied. Then the operator is treated as the
 corresponding built-in operator and interpreted according to Clause
 [[expr]].
+``` cpp
+struct X {
+  operator double();
+};
+struct Y {
+  operator int*();
+};
+int *a = Y() + 100.0;      // error: pointer arithmetic requires integral operand
+int *b = Y() + X();        // error: pointer arithmetic requires integral operand
+```
 The second operand of operator `->` is ignored in selecting an
 `operator->` function, and is not an argument when the `operator->`
 function is called. When `operator->` returns, the operator `->` is
 applied to the value returned, with the original second operand.[^7]
 Under the conditions specified in  [[dcl.init]], as part of a
 copy-initialization of an object of class type, a user-defined
 conversion can be invoked to convert an initializer expression to the
 type of the object being initialized. Overload resolution is used to
+select the user-defined conversion to be invoked. The conversion
+performed for indirect binding to a reference to a possibly cv-qualified
+class type is determined in terms of a corresponding non-reference
+copy-initialization. Assuming that “*cv1* `T`” is the type of the object
+being initialized, with `T` a class type, the candidate functions are
+selected as follows:
 - The converting constructors ([[class.conv.ctor]]) of `T` are
   candidate functions.
 - When the type of the initializer expression is a class type “*cv*
   `S`”, the non-explicit conversion functions of `S` and its base
   classes are considered. When initializing a temporary to be bound to
   the first parameter of a constructor that takes a reference to
   possibly cv-qualified `T` as its first argument, called with a single
+  argument in the context of direct-initialization of an object of type
+ “*cv2* `T`”, explicit conversion functions are also considered. Those
+ that are not hidden within `S` and yield a type whose cv-unqualified
+ version is the same type as `T` or is a derived class thereof are
+ candidate functions. Conversion functions that return “reference to
+ `X`” return lvalues or xvalues, depending on the type of reference, of
+ type `X` and are therefore considered to yield `X` for this process of
+ selecting candidate functions.
 In both cases, the argument list has one argument, which is the
 initializer expression. This argument will be compared against the first
 parameter of the constructors and against the implicit object parameter
 of the conversion functions.
 resolution is used to select the conversion function to be invoked.
 Assuming that “*cv1* `T`” is the underlying type of the reference being
 initialized, and “*cv* `S`” is the type of the initializer expression,
 with `S` a class type, the candidate functions are selected as follows:
+- The conversion functions of `S` and its base classes are considered.
+ Those non-explicit conversion functions that are not hidden within `S`
+ and yield type “lvalue reference to *cv2* `T2`” (when initializing an
+ lvalue reference or an rvalue reference to function) or “ `T2`” or
+ “rvalue reference to `T2`” (when initializing an rvalue reference or
+ an lvalue reference to function), where “*cv1* `T`” is
+  reference-compatible ([[dcl.init.ref]]) with “*cv2* `T2`”, are
+  candidate functions. For direct-initialization, those explicit
+  conversion functions that are not hidden within `S` and yield type
+  “lvalue reference to *cv2* `T2`” or “*cv2* `T2`” or “rvalue reference
+  to *cv2* `T2`,” respectively, where `T2` is the same type as `T` or
+  can be converted to type `T` with a qualification conversion (
+  [[conv.qual]]), are also candidate functions.
 The argument list has one argument, which is the initializer expression.
 This argument will be compared against the implicit object parameter of
 the conversion functions.

Diff to HTML by rtfpessoa