[over.built] - C++14 → C++17

Files changed (1) hide show

tmp/tmpjb27r_z4/{from.md → to.md} +104 -117

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

@@ -2,11 +2,13 @@
 The candidate operator functions that represent the built-in operators
 defined in Clause  [[expr]] are specified in this subclause. These
 candidate functions participate in the operator overload resolution
 process as described in  [[over.match.oper]] and are used for no other
-purpose. Because built-in operators take only operands with non-class
 type, and operator overload resolution occurs only when an operand
 expression originally has class or enumeration type, operator overload
 resolution can resolve to a built-in operator only when an operand has a
 class type that has a user-defined conversion to a non-class type
 appropriate for the operator, or when an operand has an enumeration type
@@ -17,99 +19,101 @@ in  [[over.match.oper]], after a built-in operator is selected by
 overload resolution the expression is subject to the requirements for
 the built-in operator given in Clause  [[expr]], and therefore to any
 additional semantic constraints given there. If there is a user-written
 candidate with the same name and parameter types as a built-in candidate
 operator function, the built-in operator function is hidden and is not
-included in the set of candidate functions.
 In this subclause, the term *promoted integral type* is used to refer to
-those integral types which are preserved by integral promotion
-(including e.g. `int` and `long` but excluding e.g. `char`). Similarly,
-the term *promoted arithmetic type* refers to floating types plus
-promoted integral types. In all cases where a promoted integral type or
-promoted arithmetic type is required, an operand of enumeration type
-will be acceptable by way of the integral promotions.
-For every pair (*T*, *VQ*), where *T* is an arithmetic type, and *VQ* is
-either `volatile` or empty, there exist candidate operator functions of
 the form
 ``` cpp
-VQ T& operator++(VQ T&);
-T operator++(VQ T&, int);
 ```
-For every pair (*T*, *VQ*), where *T* is an arithmetic type other than
-*bool*, and *VQ* is either `volatile` or empty, there exist candidate
-operator functions of the form
-``` cpp
-VQ T& operator--(VQ T&);
-T operator--(VQ T&, int);
-```
-For every pair (*T*, *VQ*), where *T* is a cv-qualified or
-cv-unqualified object type, and *VQ* is either `volatile` or empty,
-there exist candidate operator functions of the form
-``` cpp
-T*VQ& operator++(T*VQ&);
-T*VQ& operator--(T*VQ&);
-T*    operator++(T*VQ&, int);
-T*    operator--(T*VQ&, int);
-```
-For every cv-qualified or cv-unqualified object type *T*, there exist
 candidate operator functions of the form
 ``` cpp
 T&    operator*(T*);
 ```
-For every function type *T* that does not have cv-qualifiers or a
 *ref-qualifier*, there exist candidate operator functions of the form
 ``` cpp
 T&    operator*(T*);
 ```
-For every type *T* there exist candidate operator functions of the form
 ``` cpp
 T*    operator+(T*);
 ```
-For every promoted arithmetic type *T*, there exist candidate operator
 functions of the form
 ``` cpp
 T operator+(T);
 T operator-(T);
 ```
-For every promoted integral type *T*, there exist candidate operator
 functions of the form
 ``` cpp
 T operator~(T);
 ```
-For every quintuple (*C1*, *C2*, *T*, *CV1*, *CV2*), where *C2* is a
-class type, *C1* is the same type as C2 or is a derived class of C2, *T*
-is an object type or a function type, and *CV1* and *CV2* are
-*cv-qualifier-seq*s, there exist candidate operator functions of the
-form
 ``` cpp
-CV12 T& operator->*(CV1 C1*, CV2 T C2::*);
 ```
-where *CV12* is the union of *CV1* and *CV2*. The return type is shown
 for exposition only; see  [[expr.mptr.oper]] for the determination of
 the operator’s result type.
-For every pair of promoted arithmetic types *L* and *R*, there exist
 candidate operator functions of the form
 ``` cpp
 LR      operator*(L, R);
 LR      operator/(L, R);
@@ -121,32 +125,32 @@ bool    operator<=(L, R);
 bool    operator>=(L, R);
 bool    operator==(L, R);
 bool    operator!=(L, R);
 ```
-where *LR* is the result of the usual arithmetic conversions between
-types *L* and *R*.
-For every cv-qualified or cv-unqualified object type *T* there exist
 candidate operator functions of the form
 ``` cpp
 T*      operator+(T*, std::ptrdiff_t);
 T&      operator[](T*, std::ptrdiff_t);
 T*      operator-(T*, std::ptrdiff_t);
 T*      operator+(std::ptrdiff_t, T*);
 T&      operator[](std::ptrdiff_t, T*);
 ```
-For every *T*, where *T* is a pointer to object type, there exist
 candidate operator functions of the form
 ``` cpp
 std::ptrdiff_t   operator-(T, T);
 ```
-For every *T*, where *T* is an enumeration type or a pointer type, there
 exist candidate operator functions of the form
 ``` cpp
 bool    operator<(T, T);
 bool    operator>(T, T);
@@ -154,19 +158,19 @@ bool    operator<=(T, T);
 bool    operator>=(T, T);
 bool    operator==(T, T);
 bool    operator!=(T, T);
 ```
-For every pointer to member type *T* or type `std::nullptr_t` there
 exist candidate operator functions of the form
 ``` cpp
 bool    operator==(T, T);
 bool    operator!=(T, T);
 ```
-For every pair of promoted integral types *L* and *R*, there exist
 candidate operator functions of the form
 ``` cpp
 LR      operator%(L, R);
 LR      operator&(L, R);
@@ -174,85 +178,85 @@ LR      operator^(L, R);
 LR      operator|(L, R);
 L       operator<<(L, R);
 L       operator>>(L, R);
 ```
-where *LR* is the result of the usual arithmetic conversions between
-types *L* and *R*.
-For every triple (*L*, *VQ*, *R*), where *L* is an arithmetic type, *VQ*
-is either `volatile` or empty, and *R* is a promoted arithmetic type,
-there exist candidate operator functions of the form
 ``` cpp
-VQ L&   operator=(VQ L&, R);
-VQ L&   operator*=(VQ L&, R);
-VQ L&   operator/=(VQ L&, R);
-VQ L&   operator+=(VQ L&, R);
-VQ L&   operator-=(VQ L&, R);
 ```
-For every pair (*T*, *VQ*), where *T* is any type and *VQ* is either
-`volatile` or empty, there exist candidate operator functions of the
-form
 ``` cpp
-T*VQ&   operator=(T*VQ&, T*);
 ```
-For every pair (*T*, *VQ*), where *T* is an enumeration or pointer to
-member type and *VQ* is either `volatile` or empty, there exist
-candidate operator functions of the form
 ``` cpp
-VQ T&   operator=(VQ T&, T);
 ```
-For every pair (*T*, *VQ*), where *T* is a cv-qualified or
-cv-unqualified object type and *VQ* is either `volatile` or empty, there
-exist candidate operator functions of the form
 ``` cpp
-T*VQ&   operator+=(T*VQ&, std::ptrdiff_t);
-T*VQ&   operator-=(T*VQ&, std::ptrdiff_t);
 ```
-For every triple (*L*, *VQ*, *R*), where *L* is an integral type, *VQ*
-is either `volatile` or empty, and *R* is a promoted integral type,
-there exist candidate operator functions of the form
 ``` cpp
-VQ L&   operator%=(VQ L&, R);
-VQ L&   operator<<=(VQ L&, R);
-VQ L&   operator>>=(VQ L&, R);
-VQ L&   operator&=(VQ L&, R);
-VQ L&   operator^=(VQ L&, R);
-VQ L&   operator|=(VQ L&, R);
 ```
 There also exist candidate operator functions of the form
 ``` cpp
 bool    operator!(bool);
 bool    operator&&(bool, bool);
 bool    operator||(bool, bool);
 ```
-For every pair of promoted arithmetic types *L* and *R*, there exist
 candidate operator functions of the form
 ``` cpp
 LR      operator?:(bool, L, R);
 ```
-where *LR* is the result of the usual arithmetic conversions between
-types *L* and *R*. As with all these descriptions of candidate
-functions, this declaration serves only to describe the built-in
-operator for purposes of overload resolution. The operator “`?:`” cannot
-be overloaded.
-For every type *T*, where *T* is a pointer, pointer-to-member, or scoped
 enumeration type, there exist candidate operator functions of the form
 ``` cpp
 T       operator?:(bool, T, T);
 ```
@@ -273,10 +277,11 @@ T       operator?:(bool, T, T);
 [class.this]: class.md#class.this
 [conv]: conv.md#conv
 [conv.array]: conv.md#conv.array
 [conv.bool]: conv.md#conv.bool
 [conv.double]: conv.md#conv.double
 [conv.fpint]: conv.md#conv.fpint
 [conv.fpprom]: conv.md#conv.fpprom
 [conv.func]: conv.md#conv.func
 [conv.integral]: conv.md#conv.integral
 [conv.lval]: conv.md#conv.lval
@@ -285,16 +290,19 @@ T       operator?:(bool, T, T);
 [conv.ptr]: conv.md#conv.ptr
 [conv.qual]: conv.md#conv.qual
 [cpp]: cpp.md#cpp
 [dcl.array]: dcl.md#dcl.array
 [dcl.fct]: dcl.md#dcl.fct
 [dcl.fct.default]: dcl.md#dcl.fct.default
 [dcl.init]: dcl.md#dcl.init
 [dcl.init.aggr]: dcl.md#dcl.init.aggr
 [dcl.init.list]: dcl.md#dcl.init.list
 [dcl.init.ref]: dcl.md#dcl.init.ref
 [dcl.typedef]: dcl.md#dcl.typedef
 [expr]: expr.md#expr
 [expr.ass]: expr.md#expr.ass
 [expr.call]: expr.md#expr.call
 [expr.cast]: expr.md#expr.cast
 [expr.cond]: expr.md#expr.cond
@@ -325,10 +333,11 @@ T       operator?:(bool, T, T);
 [over.literal]: #over.literal
 [over.load]: #over.load
 [over.match]: #over.match
 [over.match.best]: #over.match.best
 [over.match.call]: #over.match.call
 [over.match.conv]: #over.match.conv
 [over.match.copy]: #over.match.copy
 [over.match.ctor]: #over.match.ctor
 [over.match.funcs]: #over.match.funcs
 [over.match.list]: #over.match.list
@@ -406,33 +415,11 @@ T       operator?:(bool, T, T);
     tournament `F` encountered another function `G` such that `F` was
     not better than `G`. Hence, `W` is either the best function or there
     is no best function. So, make a second pass over the viable
     functions to verify that `W` is better than all other functions.
-[^11]: The ambiguous conversion sequence is ranked with user-defined
- conversion sequences because multiple conversion sequences for an
-    argument can exist only if they involve different user-defined
-    conversions. The ambiguous conversion sequence is indistinguishable
-    from any other user-defined conversion sequence because it
-    represents at least two user-defined conversion sequences, each with
-    a different user-defined conversion, and any other user-defined
-    conversion sequence must be indistinguishable from at least one of
-    them.
-    This rule prevents a function from becoming non-viable because of an
-    ambiguous conversion sequence for one of its parameters. Consider
-    this example,
-    If it were not for this rule, `f(A)` would be eliminated as a viable
-    function for the call `f(b)` causing overload resolution to select
-    `f(C)` as the function to call even though it is not clearly the
-    best choice. On the other hand, if an `f(B)` were to be declared
-    then `f(b)` would resolve to that `f(B)` because the exact match
-    with `f(B)` is better than any of the sequences required to match
-    `f(A)`.
-[^12]: Since there are no parameters of array type, this will only occur
-    as the underlying type of a reference parameter.
-[^13]: Calling `operator++` explicitly, as in expressions like
     `a.operator++(2)`, has no special properties: The argument to
     `operator++` is `2`.

 The candidate operator functions that represent the built-in operators
 defined in Clause  [[expr]] are specified in this subclause. These
 candidate functions participate in the operator overload resolution
 process as described in  [[over.match.oper]] and are used for no other
+purpose.
+[*Note 1*: Because built-in operators take only operands with non-class
 type, and operator overload resolution occurs only when an operand
 expression originally has class or enumeration type, operator overload
 resolution can resolve to a built-in operator only when an operand has a
 class type that has a user-defined conversion to a non-class type
 appropriate for the operator, or when an operand has an enumeration type
 overload resolution the expression is subject to the requirements for
 the built-in operator given in Clause  [[expr]], and therefore to any
 additional semantic constraints given there. If there is a user-written
 candidate with the same name and parameter types as a built-in candidate
 operator function, the built-in operator function is hidden and is not
+included in the set of candidate functions. — *end note*]
 In this subclause, the term *promoted integral type* is used to refer to
+those integral types which are preserved by integral promotion (
+[[conv.prom]]) (including e.g. `int` and `long` but excluding e.g.
+`char`). Similarly, the term *promoted arithmetic type* refers to
+floating types plus promoted integral types.
+[*Note 2*: In all cases where a promoted integral type or promoted
+arithmetic type is required, an operand of enumeration type will be
+acceptable by way of the integral promotions. — *end note*]
+In the remainder of this section, *vq* represents either `volatile` or
+no cv-qualifier.
+For every pair (`T`, *vq*), where `T` is an arithmetic type other than
+`bool`, there exist candidate operator functions of the form
+``` cpp
+vq T& operator++(vq T&);
+T operator++(vq T&, int);
+```
+For every pair (`T`, *vq*), where `T` is an arithmetic type other than
+`bool`, there exist candidate operator functions of the form
+``` cpp
+vq T& operator--(vq T&);
+T operator--(vq T&, int);
+```
+For every pair (`T`, *vq*), where `T` is a cv-qualified or
+cv-unqualified object type, there exist candidate operator functions of
 the form
 ``` cpp
+T*vq& operator++(T*vq&);
+T*vq& operator--(T*vq&);
+T*    operator++(T*vq&, int);
+T*    operator--(T*vq&, int);
 ```
+For every cv-qualified or cv-unqualified object type `T`, there exist
 candidate operator functions of the form
 ``` cpp
 T&    operator*(T*);
 ```
+For every function type `T` that does not have cv-qualifiers or a
 *ref-qualifier*, there exist candidate operator functions of the form
 ``` cpp
 T&    operator*(T*);
 ```
+For every type `T` there exist candidate operator functions of the form
 ``` cpp
 T*    operator+(T*);
 ```
+For every promoted arithmetic type `T`, there exist candidate operator
 functions of the form
 ``` cpp
 T operator+(T);
 T operator-(T);
 ```
+For every promoted integral type `T`, there exist candidate operator
 functions of the form
 ``` cpp
 T operator~(T);
 ```
+For every quintuple (`C1`, `C2`, `T`, *cv1*, *cv2*), where `C2` is a
+class type, `C1` is the same type as `C2` or is a derived class of `C2`,
+and `T` is an object type or a function type, there exist candidate
+operator functions of the form
 ``` cpp
+cv12 T& operator->*(cv1 C1*, cv2 T C2::*);
 ```
+where *cv12* is the union of *cv1* and *cv2*. The return type is shown
 for exposition only; see  [[expr.mptr.oper]] for the determination of
 the operator’s result type.
+For every pair of promoted arithmetic types `L` and `R`, there exist
 candidate operator functions of the form
 ``` cpp
 LR      operator*(L, R);
 LR      operator/(L, R);
 bool    operator>=(L, R);
 bool    operator==(L, R);
 bool    operator!=(L, R);
 ```
+where `LR` is the result of the usual arithmetic conversions between
+types `L` and `R`.
+For every cv-qualified or cv-unqualified object type `T` there exist
 candidate operator functions of the form
 ``` cpp
 T*      operator+(T*, std::ptrdiff_t);
 T&      operator[](T*, std::ptrdiff_t);
 T*      operator-(T*, std::ptrdiff_t);
 T*      operator+(std::ptrdiff_t, T*);
 T&      operator[](std::ptrdiff_t, T*);
 ```
+For every `T`, where `T` is a pointer to object type, there exist
 candidate operator functions of the form
 ``` cpp
 std::ptrdiff_t   operator-(T, T);
 ```
+For every `T`, where `T` is an enumeration type or a pointer type, there
 exist candidate operator functions of the form
 ``` cpp
 bool    operator<(T, T);
 bool    operator>(T, T);
 bool    operator>=(T, T);
 bool    operator==(T, T);
 bool    operator!=(T, T);
 ```
+For every pointer to member type `T` or type `std::nullptr_t` there
 exist candidate operator functions of the form
 ``` cpp
 bool    operator==(T, T);
 bool    operator!=(T, T);
 ```
+For every pair of promoted integral types `L` and `R`, there exist
 candidate operator functions of the form
 ``` cpp
 LR      operator%(L, R);
 LR      operator&(L, R);
 LR      operator|(L, R);
 L       operator<<(L, R);
 L       operator>>(L, R);
 ```
+where `LR` is the result of the usual arithmetic conversions between
+types `L` and `R`.
+For every triple (`L`, *vq*, `R`), where `L` is an arithmetic type, and
+`R` is a promoted arithmetic type, there exist candidate operator
+functions of the form
 ``` cpp
+vq L&   operator=(vq L&, R);
+vq L&   operator*=(vq L&, R);
+vq L&   operator/=(vq L&, R);
+vq L&   operator+=(vq L&, R);
+vq L&   operator-=(vq L&, R);
 ```
+For every pair (`T`, *vq*), where `T` is any type, there exist candidate
+operator functions of the form
 ``` cpp
+T*vq&   operator=(T*vq&, T*);
 ```
+For every pair (`T`, *vq*), where `T` is an enumeration or pointer to
+member type, there exist candidate operator functions of the form
 ``` cpp
+vq T&   operator=(vq T&, T);
 ```
+For every pair (`T`, *vq*), where `T` is a cv-qualified or
+cv-unqualified object type, there exist candidate operator functions of
+the form
 ``` cpp
+T*vq&   operator+=(T*vq&, std::ptrdiff_t);
+T*vq&   operator-=(T*vq&, std::ptrdiff_t);
 ```
+For every triple (`L`, *vq*, `R`), where `L` is an integral type, and
+`R` is a promoted integral type, there exist candidate operator
+functions of the form
 ``` cpp
+vq L&   operator%=(vq L&, R);
+vq L&   operator<<=(vq L&, R);
+vq L&   operator>>=(vq L&, R);
+vq L&   operator&=(vq L&, R);
+vq L&   operator^=(vq L&, R);
+vq L&   operator|=(vq L&, R);
 ```
 There also exist candidate operator functions of the form
 ``` cpp
 bool    operator!(bool);
 bool    operator&&(bool, bool);
 bool    operator||(bool, bool);
 ```
+For every pair of promoted arithmetic types `L` and `R`, there exist
 candidate operator functions of the form
 ``` cpp
 LR      operator?:(bool, L, R);
 ```
+where `LR` is the result of the usual arithmetic conversions between
+types `L` and `R`.
+[*Note 3*: As with all these descriptions of candidate functions, this
+declaration serves only to describe the built-in operator for purposes
+of overload resolution. The operator “`?:`” cannot be
+overloaded. — *end note*]
+For every type `T`, where `T` is a pointer, pointer-to-member, or scoped
 enumeration type, there exist candidate operator functions of the form
 ``` cpp
 T       operator?:(bool, T, T);
 ```
 [class.this]: class.md#class.this
 [conv]: conv.md#conv
 [conv.array]: conv.md#conv.array
 [conv.bool]: conv.md#conv.bool
 [conv.double]: conv.md#conv.double
+[conv.fctptr]: conv.md#conv.fctptr
 [conv.fpint]: conv.md#conv.fpint
 [conv.fpprom]: conv.md#conv.fpprom
 [conv.func]: conv.md#conv.func
 [conv.integral]: conv.md#conv.integral
 [conv.lval]: conv.md#conv.lval
 [conv.ptr]: conv.md#conv.ptr
 [conv.qual]: conv.md#conv.qual
 [cpp]: cpp.md#cpp
 [dcl.array]: dcl.md#dcl.array
 [dcl.fct]: dcl.md#dcl.fct
+[dcl.fct.def.delete]: dcl.md#dcl.fct.def.delete
 [dcl.fct.default]: dcl.md#dcl.fct.default
 [dcl.init]: dcl.md#dcl.init
 [dcl.init.aggr]: dcl.md#dcl.init.aggr
 [dcl.init.list]: dcl.md#dcl.init.list
 [dcl.init.ref]: dcl.md#dcl.init.ref
+[dcl.init.string]: dcl.md#dcl.init.string
 [dcl.typedef]: dcl.md#dcl.typedef
+[except.spec]: except.md#except.spec
 [expr]: expr.md#expr
 [expr.ass]: expr.md#expr.ass
 [expr.call]: expr.md#expr.call
 [expr.cast]: expr.md#expr.cast
 [expr.cond]: expr.md#expr.cond
 [over.literal]: #over.literal
 [over.load]: #over.load
 [over.match]: #over.match
 [over.match.best]: #over.match.best
 [over.match.call]: #over.match.call
+[over.match.class.deduct]: #over.match.class.deduct
 [over.match.conv]: #over.match.conv
 [over.match.copy]: #over.match.copy
 [over.match.ctor]: #over.match.ctor
 [over.match.funcs]: #over.match.funcs
 [over.match.list]: #over.match.list
     tournament `F` encountered another function `G` such that `F` was
     not better than `G`. Hence, `W` is either the best function or there
     is no best function. So, make a second pass over the viable
     functions to verify that `W` is better than all other functions.
+[^11]: Since there are no parameters of array type, this will only occur
+ as the referenced type of a reference parameter.
+[^12]: Calling `operator++` explicitly, as in expressions like
     `a.operator++(2)`, has no special properties: The argument to
     `operator++` is `2`.

Diff to HTML by rtfpessoa