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

Files changed (1) hide show

tmp/tmpdqkntq5k/{from.md → to.md} +54 -31

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

@@ -11,13 +11,13 @@ operator named in its *operator-function-id*.
 ``` bnf
 operator-function-id:
     'operator' operator
 ```
-The last two operators are function call ([[expr.call]]) and
-subscripting ([[expr.sub]]). The operators `new[]`, `delete[]`, `()`,
-and `[]` are formed from more than one token.
 Both the unary and binary forms of
 ``` cpp
 +    -    *     &
@@ -37,15 +37,19 @@ Operator functions are usually not called directly; instead they are
 invoked to evaluate the operators they implement ([[over.unary]] –
 [[over.inc]]). They can be explicitly called, however, using the
 *operator-function-id* as the name of the function in the function call
 syntax ([[expr.call]]).
 ``` cpp
 complex z = a.operator+(b);     // complex z = a+b;
 void* p = operator new(sizeof(int)*n);
 ```
 The allocation and deallocation functions, `operator` `new`, `operator`
 `new[]`, `operator` `delete` and `operator` `delete[]`, are described
 completely in  [[basic.stc.dynamic]]. The attributes and restrictions
 found in the rest of this subclause do not apply to them unless
 explicitly stated in  [[basic.stc.dynamic]].
@@ -85,12 +89,14 @@ of the operator function have been declared, the rules in
 [[over.match.oper]] determine which, if any, interpretation is used.
 See  [[over.inc]] for an explanation of the postfix unary operators `++`
 and `\dcr`.
 The unary and binary forms of the same operator are considered to have
-the same name. Consequently, a unary operator can hide a binary operator
-from an enclosing scope, and vice versa.
 ### Binary operators <a id="over.binary">[[over.binary]]</a>
 A binary operator shall be implemented either by a non-static member
 function ([[class.mfct]]) with one parameter or by a non-member
@@ -106,14 +112,20 @@ function with exactly one parameter. Because a copy assignment operator
 `operator=` is implicitly declared for a class if not declared by the
 user ([[class.copy]]), a base class assignment operator is always
 hidden by the copy assignment operator of the derived class.
 Any assignment operator, even the copy and move assignment operators,
-can be virtual. For a derived class `D` with a base class `B` for which
-a virtual copy/move assignment has been declared, the copy/move
-assignment operator in `D` does not override `B`’s virtual copy/move
-assignment operator.
 ``` cpp
 struct B {
   virtual int operator= (int);
   virtual B& operator= (const B&);
@@ -129,15 +141,18 @@ B* bptr = &dobj1;
 void f() {
   bptr->operator=(99);          // calls D::operator=(int)
   *bptr = 99;                   // ditto
   bptr->operator=(dobj2);       // calls D::operator=(const B&)
   *bptr = dobj2;                // ditto
-  dobj1 = dobj2;                // calls implicitly-declared
-                                // D::operator=(const D&)
 }
 ```
 ### Function call <a id="over.call">[[over.call]]</a>
 `operator()`
 shall be a non-static member function with an arbitrary number of
@@ -162,35 +177,33 @@ mechanism ([[over.match.best]]).
 shall be a non-static member function with exactly one parameter. It
 implements the subscripting syntax
 ``` bnf
-postfix-expression '[' expression ']'
-```
-or
-``` bnf
-postfix-expression '[' braced-init-list ']'
 ```
 Thus, a subscripting expression `x[y]` is interpreted as
 `x.operator[](y)` for a class object `x` of type `T` if
 `T::operator[](T1)` exists and if the operator is selected as the best
 match function by the overload resolution mechanism (
 [[over.match.best]]).
 ``` cpp
 struct X {
   Z operator[](std::initializer_list<int>);
 };
 X x;
 x[{1,2,3}] = 7;           // OK: meaning x.operator[]({1,2,3\)}
 int a[10];
 a[{1,2,3}] = 7;           // error: built-in subscript operator
 ```
 ### Class member access <a id="over.ref">[[over.ref]]</a>
 `operator->`
 shall be a non-static member function taking no parameters. It
@@ -215,11 +228,13 @@ defines the prefix increment operator `++` for objects of that type. If
 the function is a non-static member function with one parameter (which
 shall be of type `int`) or a non-member function with two parameters
 (the second of which shall be of type `int`), it defines the postfix
 increment operator `++` for objects of that type. When the postfix
 increment is called as a result of using the `++` operator, the `int`
-argument will have value zero.[^13]
 ``` cpp
 struct X {
   X&   operator++();            // prefix ++a
   X    operator++(int);         // postfix a++
@@ -240,10 +255,12 @@ void f(X a, Y b) {
   operator++(b);                // explicit call: like ++b;
   operator++(b, 0);             // explicit call: like b++;
 }
 ```
 The prefix and postfix decrement operators `-{-}` are handled
 analogously.
 ### User-defined literals <a id="over.literal">[[over.literal]]</a>
@@ -255,13 +272,14 @@ literal-operator-id:
 The *string-literal* or *user-defined-string-literal* in a
 *literal-operator-id* shall have no *encoding-prefix* and shall contain
 no characters other than the implicit terminating `'\0'`. The
 *ud-suffix* of the *user-defined-string-literal* or the *identifier* in
-a *literal-operator-id* is called a *literal suffix identifier*. some
 literal suffix identifiers are reserved for future standardization; see
-[[usrlit.suffix]].
 A declaration whose *declarator-id* is a *literal-operator-id* shall be
 a declaration of a namespace-scope function or function template (it
 could be a friend function ([[class.friend]])), an explicit
 instantiation or specialization of a function template, or a
@@ -298,29 +316,34 @@ have a single *template-parameter* that is a non-type template parameter
 pack ([[temp.variadic]]) with element type `char`.
 Literal operators and literal operator templates shall not have C
 language linkage.
-Literal operators and literal operator templates are usually invoked
-implicitly through user-defined literals ([[lex.ext]]). However, except
-for the constraints described above, they are ordinary namespace-scope
-functions and function templates. In particular, they are looked up like
-ordinary functions and function templates and they follow the same
-overload resolution rules. Also, they can be declared `inline` or
-`constexpr`, they may have internal or external linkage, they can be
-called explicitly, their addresses can be taken, etc.
 ``` cpp
 void operator "" _km(long double);                  // OK
 string operator "" _i18n(const char*, std::size_t); // OK
 template <char...> double operator "" _\u03C0();    // OK: UCN for lowercase pi
 float operator ""_e(const char*);                   // OK
 float operator ""E(const char*);                    // error: reserved literal suffix~([usrlit.suffix], [lex.ext])
-double operator""_Bq(long double);                  // OK: does not use the reserved name _Bq~([global.names])
-double operator"" _Bq(long double);                 // uses the reserved name _Bq~([global.names])
 float operator " " B(const char*);                  // error: non-empty string-literal
 string operator "" 5X(const char*, std::size_t);    // error: invalid literal suffix identifier
 double operator "" _miles(double);                  // error: invalid parameter-declaration-clause
 template <char...> int operator "" _j(const char*); // error: invalid parameter-declaration-clause
 extern "C" void operator "" _m(long double);        // error: C language linkage
 ```

 ``` bnf
 operator-function-id:
     'operator' operator
 ```
+[*Note 1*: The last two operators are function call ([[expr.call]])
+and subscripting ([[expr.sub]]). The operators `new[]`, `delete[]`,
+`()`, and `[]` are formed from more than one token. — *end note*]
 Both the unary and binary forms of
 ``` cpp
 +    -    *     &
 invoked to evaluate the operators they implement ([[over.unary]] –
 [[over.inc]]). They can be explicitly called, however, using the
 *operator-function-id* as the name of the function in the function call
 syntax ([[expr.call]]).
+[*Example 1*:
 ``` cpp
 complex z = a.operator+(b);     // complex z = a+b;
 void* p = operator new(sizeof(int)*n);
 ```
+— *end example*]
 The allocation and deallocation functions, `operator` `new`, `operator`
 `new[]`, `operator` `delete` and `operator` `delete[]`, are described
 completely in  [[basic.stc.dynamic]]. The attributes and restrictions
 found in the rest of this subclause do not apply to them unless
 explicitly stated in  [[basic.stc.dynamic]].
 [[over.match.oper]] determine which, if any, interpretation is used.
 See  [[over.inc]] for an explanation of the postfix unary operators `++`
 and `\dcr`.
 The unary and binary forms of the same operator are considered to have
+the same name.
+[*Note 1*: Consequently, a unary operator can hide a binary operator
+from an enclosing scope, and vice versa. — *end note*]
 ### Binary operators <a id="over.binary">[[over.binary]]</a>
 A binary operator shall be implemented either by a non-static member
 function ([[class.mfct]]) with one parameter or by a non-member
 `operator=` is implicitly declared for a class if not declared by the
 user ([[class.copy]]), a base class assignment operator is always
 hidden by the copy assignment operator of the derived class.
 Any assignment operator, even the copy and move assignment operators,
+can be virtual.
+[*Note 1*:
+For a derived class `D` with a base class `B` for which a virtual
+copy/move assignment has been declared, the copy/move assignment
+operator in `D` does not override `B`’s virtual copy/move assignment
+operator.
+[*Example 1*:
 ``` cpp
 struct B {
   virtual int operator= (int);
   virtual B& operator= (const B&);
 void f() {
   bptr->operator=(99);          // calls D::operator=(int)
   *bptr = 99;                   // ditto
   bptr->operator=(dobj2);       // calls D::operator=(const B&)
   *bptr = dobj2;                // ditto
+  dobj1 = dobj2;                // calls implicitly-declared D::operator=(const D&)
 }
 ```
+— *end example*]
+— *end note*]
 ### Function call <a id="over.call">[[over.call]]</a>
 `operator()`
 shall be a non-static member function with an arbitrary number of
 shall be a non-static member function with exactly one parameter. It
 implements the subscripting syntax
 ``` bnf
+postfix-expression '[' expr-or-braced-init-list ']'
 ```
 Thus, a subscripting expression `x[y]` is interpreted as
 `x.operator[](y)` for a class object `x` of type `T` if
 `T::operator[](T1)` exists and if the operator is selected as the best
 match function by the overload resolution mechanism (
 [[over.match.best]]).
+[*Example 1*:
 ``` cpp
 struct X {
   Z operator[](std::initializer_list<int>);
 };
 X x;
 x[{1,2,3}] = 7;           // OK: meaning x.operator[]({1,2,3\)}
 int a[10];
 a[{1,2,3}] = 7;           // error: built-in subscript operator
 ```
+— *end example*]
 ### Class member access <a id="over.ref">[[over.ref]]</a>
 `operator->`
 shall be a non-static member function taking no parameters. It
 the function is a non-static member function with one parameter (which
 shall be of type `int`) or a non-member function with two parameters
 (the second of which shall be of type `int`), it defines the postfix
 increment operator `++` for objects of that type. When the postfix
 increment is called as a result of using the `++` operator, the `int`
+argument will have value zero.[^12]
+[*Example 1*:
 ``` cpp
 struct X {
   X&   operator++();            // prefix ++a
   X    operator++(int);         // postfix a++
   operator++(b);                // explicit call: like ++b;
   operator++(b, 0);             // explicit call: like b++;
 }
 ```
+— *end example*]
 The prefix and postfix decrement operators `-{-}` are handled
 analogously.
 ### User-defined literals <a id="over.literal">[[over.literal]]</a>
 The *string-literal* or *user-defined-string-literal* in a
 *literal-operator-id* shall have no *encoding-prefix* and shall contain
 no characters other than the implicit terminating `'\0'`. The
 *ud-suffix* of the *user-defined-string-literal* or the *identifier* in
+a *literal-operator-id* is called a *literal suffix identifier*. Some
 literal suffix identifiers are reserved for future standardization; see
+[[usrlit.suffix]]. A declaration whose *literal-operator-id* uses such a
+literal suffix identifier is ill-formed, no diagnostic required.
 A declaration whose *declarator-id* is a *literal-operator-id* shall be
 a declaration of a namespace-scope function or function template (it
 could be a friend function ([[class.friend]])), an explicit
 instantiation or specialization of a function template, or a
 pack ([[temp.variadic]]) with element type `char`.
 Literal operators and literal operator templates shall not have C
 language linkage.
+[*Note 1*: Literal operators and literal operator templates are usually
+invoked implicitly through user-defined literals ([[lex.ext]]).
+However, except for the constraints described above, they are ordinary
+namespace-scope functions and function templates. In particular, they
+are looked up like ordinary functions and function templates and they
+follow the same overload resolution rules. Also, they can be declared
+`inline` or `constexpr`, they may have internal or external linkage,
+they can be called explicitly, their addresses can be taken,
+etc. — *end note*]
+[*Example 1*:
 ``` cpp
 void operator "" _km(long double);                  // OK
 string operator "" _i18n(const char*, std::size_t); // OK
 template <char...> double operator "" _\u03C0();    // OK: UCN for lowercase pi
 float operator ""_e(const char*);                   // OK
 float operator ""E(const char*);                    // error: reserved literal suffix~([usrlit.suffix], [lex.ext])
+double operator""_Bq(long double);                  // OK: does not use the reserved identifier _Bq~([lex.name])
+double operator"" _Bq(long double);                 // uses the reserved identifier _Bq~([lex.name])
 float operator " " B(const char*);                  // error: non-empty string-literal
 string operator "" 5X(const char*, std::size_t);    // error: invalid literal suffix identifier
 double operator "" _miles(double);                  // error: invalid parameter-declaration-clause
 template <char...> int operator "" _j(const char*); // error: invalid parameter-declaration-clause
 extern "C" void operator "" _m(long double);        // error: C language linkage
 ```
+— *end example*]

Diff to HTML by rtfpessoa