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

Files changed (1) hide show

tmp/tmp6bu1ufaj/{from.md → to.md} +169 -184

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

@@ -8,38 +8,53 @@ template*. A specialization of an operator function template is also an
 operator function. An operator function is said to *implement* the
 operator named in its *operator-function-id*.
 ``` 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
-+ - * &
 ```
 can be overloaded.
 The following operators cannot be overloaded:
-``` cpp
-. .* :: ?:
 ```
-nor can the preprocessing symbols `#` and `##` (Clause  [[cpp]]).
 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]]).
 [*Example 1*:
 ``` cpp
 complex z = a.operator+(b);     // complex z = a+b;
@@ -47,83 +62,133 @@ 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]].
 An operator function shall either be a non-static member function or be
 a non-member function that has at least one parameter whose type is a
 class, a reference to a class, an enumeration, or a reference to an
 enumeration. It is not possible to change the precedence, grouping, or
 number of operands of operators. The meaning of the operators `=`,
 (unary) `&`, and `,` (comma), predefined for each type, can be changed
-for specific class and enumeration types by defining operator functions
-that implement these operators. Operator functions are inherited in the
-same manner as other base class functions.
-The identities among certain predefined operators applied to basic types
-(for example, `++a` ≡ `a+=1`) need not hold for operator functions. Some
-predefined operators, such as `+=`, require an operand to be an lvalue
-when applied to basic types; this is not required by operator functions.
-An operator function cannot have default arguments (
-[[dcl.fct.default]]), except where explicitly stated below. Operator
-functions cannot have more or fewer parameters than the number required
-for the corresponding operator, as described in the rest of this
-subclause.
 Operators not mentioned explicitly in subclauses  [[over.ass]] through
 [[over.inc]] act as ordinary unary and binary operators obeying the
 rules of  [[over.unary]] or  [[over.binary]].
 ### Unary operators <a id="over.unary">[[over.unary]]</a>
-A prefix unary operator shall be implemented by a non-static member
-function ([[class.mfct]]) with no parameters or a non-member function
-with one parameter. Thus, for any prefix unary operator `@`, `@x` can be
-interpreted as either `x.operator@()` or `operator@(x)`. If both forms
-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.
-[*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
-function with two parameters. Thus, for any binary operator `@`, `x@y`
-can be interpreted as either `x.operator@(y)` or `operator@(x,y)`. If
-both forms of the operator function have been declared, the rules in
-[[over.match.oper]] determine which, if any, interpretation is used.
-### Assignment <a id="over.ass">[[over.ass]]</a>
-An assignment operator shall be implemented by a non-static member
-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.
-[*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 {
@@ -151,44 +216,50 @@ void f() {
 — *end note*]
 ### Function call <a id="over.call">[[over.call]]</a>
-`operator()`
-shall be a non-static member function with an arbitrary number of
-parameters. It can have default arguments. It implements the function
-call syntax
 ``` bnf
 postfix-expression '(' expression-listₒₚₜ ')'
 ```
-where the *postfix-expression* evaluates to a class object and the
-possibly empty *expression-list* matches the parameter list of an
-`operator()` member function of the class. Thus, a call `x(arg1,...)` is
-interpreted as `x.operator()(arg1, ...)` for a class object `x` of type
-`T` if `T::operator()(T1,` `T2,` `T3)` exists and if the operator is
-selected as the best match function by the overload resolution
-mechanism ([[over.match.best]]).
 ### Subscripting <a id="over.sub">[[over.sub]]</a>
-`operator[]`
-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 {
@@ -202,37 +273,36 @@ 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
-implements the class member access syntax that uses `->`.
 ``` bnf
-postfix-expression '->' 'template'ₒₚₜ id-expression
-postfix-expression '->' pseudo-destructor-name
 ```
-An expression `x->m` is interpreted as `(x.operator->())->m` for a class
-object `x` of type `T` if `T::operator->()` exists and if the operator
-is selected as the best match function by the overload resolution
-mechanism ([[over.match]]).
 ### Increment and decrement <a id="over.inc">[[over.inc]]</a>
-The user-defined function called `operator++` implements the prefix and
-postfix `++` operator. If this function is a non-static member function
-with no parameters, or a non-member function with one parameter, it
-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.[^12]
 [*Example 1*:
 ``` cpp
 struct X {
@@ -257,93 +327,8 @@ void f(X a, Y b) {
 }
 ```
 — *end example*]
-The prefix and postfix decrement operators `-{-}` are handled
-analogously.
-### User-defined literals <a id="over.literal">[[over.literal]]</a>
-``` bnf
-literal-operator-id:
-    'operator' string-literal identifier
-    'operator' user-defined-string-literal
-```
-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
-*using-declaration* ([[namespace.udecl]]). A function declared with a
-*literal-operator-id* is a *literal operator*. A function template
-declared with a *literal-operator-id* is a *literal operator template*.
-The declaration of a literal operator shall have a
-*parameter-declaration-clause* equivalent to one of the following:
-``` cpp
-const char*
-unsigned long long int
-long double
-char
-wchar_t
-char16_t
-char32_t
-const char*, std::size_t
-const wchar_t*, std::size_t
-const char16_t*, std::size_t
-const char32_t*, std::size_t
-```
-If a parameter has a default argument ([[dcl.fct.default]]), the
-program is ill-formed.
-A *raw literal operator* is a literal operator with a single parameter
-whose type is `const char*`.
-The declaration of a literal operator template shall have an empty
-*parameter-declaration-clause* and its *template-parameter-list* shall
-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.
-[*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*]

 operator function. An operator function is said to *implement* the
 operator named in its *operator-function-id*.
 ``` bnf
 operator-function-id:
+    operator operator
 ```
+``` bnf
+%% Ed. note: character protrusion would misalign various operators.
+operator: one of
+    'new delete new[] delete[] co_await ( ) [ ] -> ->*'
+    '~ ! + - * / % ^ &'
+    '| = += -= *= /= %= ^= &='
+    '|= == != < > <= >= <=> &&'
+    '|| << >> <<= >>= ++ -- ,'
+```
+[*Note 1*: The operators `new[]`, `delete[]`, `()`, and `[]` are formed
+from more than one token. The latter two operators are function call
+[[expr.call]] and subscripting [[expr.sub]]. — *end note*]
 Both the unary and binary forms of
+``` bnf
+'+ - * &'
 ```
 can be overloaded.
+[*Note 2*:
 The following operators cannot be overloaded:
+``` bnf
+'. .* :: ?:'
 ```
+nor can the preprocessing symbols `#` [[cpp.stringize]] and `##`
+[[cpp.concat]].
+— *end note*]
 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]].
 [*Example 1*:
 ``` cpp
 complex z = a.operator+(b);     // complex z = a+b;
 ```
 — *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]].
+The `co_await` operator is described completely in  [[expr.await]]. The
+attributes and restrictions found in the rest of this subclause do not
+apply to it unless explicitly stated in  [[expr.await]].
 An operator function shall either be a non-static member function or be
 a non-member function that has at least one parameter whose type is a
 class, a reference to a class, an enumeration, or a reference to an
 enumeration. It is not possible to change the precedence, grouping, or
 number of operands of operators. The meaning of the operators `=`,
 (unary) `&`, and `,` (comma), predefined for each type, can be changed
+for specific class types by defining operator functions that implement
+these operators. Likewise, the meaning of the operators (unary) `&` and
+`,` (comma) can be changed for specific enumeration types. Operator
+functions are inherited in the same manner as other base class
+functions.
+An operator function shall be a prefix unary, binary, function call,
+subscripting, class member access, increment, or decrement operator
+function.
+[*Note 3*: The identities among certain predefined operators applied to
+basic types (for example, `++a` ≡ `a+=1`) need not hold for operator
+functions. Some predefined operators, such as `+=`, require an operand
+to be an lvalue when applied to basic types; this is not required by
+operator functions. — *end note*]
+An operator function cannot have default arguments [[dcl.fct.default]],
+except where explicitly stated below. Operator functions cannot have
+more or fewer parameters than the number required for the corresponding
+operator, as described in the rest of this subclause.
 Operators not mentioned explicitly in subclauses  [[over.ass]] through
 [[over.inc]] act as ordinary unary and binary operators obeying the
 rules of  [[over.unary]] or  [[over.binary]].
 ### Unary operators <a id="over.unary">[[over.unary]]</a>
+A *prefix unary operator function* is a function named `operator@` for a
+prefix *unary-operator* `@` [[expr.unary.op]] that is either a
+non-static member function [[class.mfct]] with no parameters or a
+non-member function with one parameter. For a *unary-expression* of the
+form `@ cast-expression`, the operator function is selected by overload
+resolution [[over.match.oper]]. If a member function is selected, the
+expression is interpreted as
+``` bnf
+cast-expression '.' operator '@' '('')'
+```
+Otherwise, if a non-member function is selected, the expression is
+interpreted as
+``` bnf
+operator '@' '(' cast-expression ')'
+```
+[*Note 1*: The operators `++` and `\dcr` [[expr.pre.incr]] are
+described in  [[over.inc]]. — *end note*]
 The unary and binary forms of the same operator are considered to have
 the same name.
+[*Note 2*: 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 function* is a function named `operator@` for a
+binary operator `@` that is either a non-static member function
+[[class.mfct]] with one parameter or a non-member function with two
+parameters. For an expression `x @ y` with subexpressions x and y, the
+operator function is selected by overload resolution
+[[over.match.oper]]. If a member function is selected, the expression is
+interpreted as
+``` bnf
+x '.' operator '@' '(' y ')'
+```
+Otherwise, if a non-member function is selected, the expression is
+interpreted as
+``` bnf
+operator '@' '(' x ',' y ')'
+```
+An *equality operator function* is an operator function for an equality
+operator [[expr.eq]]. A *relational operator function* is an operator
+function for a relational operator [[expr.rel]]. A
+*three-way comparison operator function* is an operator function for the
+three-way comparison operator [[expr.spaceship]]. A
+*comparison operator function* is an equality operator function, a
+relational operator function, or a three-way comparison operator
+function.
+#### Simple assignment <a id="over.ass">[[over.ass]]</a>
+A *simple assignment operator function* is a binary operator function
+named `operator=`. A simple assignment operator function shall be a
+non-static member function.
+[*Note 1*: Because only standard conversion sequences are considered
+when converting to the left operand of an assignment operation
+[[over.best.ics]], an expression `x = y` with a subexpression x of class
+type is always interpreted as `x.operator=(y)`. — *end note*]
+[*Note 2*: Since a copy assignment operator is implicitly declared for
+a class if not declared by the user [[class.copy.assign]], a base class
+assignment operator function is always hidden by the copy assignment
+operator function of the derived class. — *end note*]
+[*Note 3*:
+Any assignment operator function, 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.
 [*Example 1*:
 ``` cpp
 struct B {
 — *end note*]
 ### Function call <a id="over.call">[[over.call]]</a>
+A *function call operator function* is a function named `operator()`
+that is a non-static member function with an arbitrary number of
+parameters. It may have default arguments. For an expression of the form
 ``` bnf
 postfix-expression '(' expression-listₒₚₜ ')'
 ```
+where the *postfix-expression* is of class type, the operator function
+is selected by overload resolution [[over.call.object]]. If a surrogate
+call function for a conversion function named `operator`
+*conversion-type-id* is selected, the expression is interpreted as
+``` bnf
+postfix-expression '.' operator conversion-type-id '('')' '(' expression-listₒₚₜ ')'
+```
+Otherwise, the expression is interpreted as
+``` bnf
+postfix-expression '.' operator '('')' '(' expression-listₒₚₜ ')'
+```
 ### Subscripting <a id="over.sub">[[over.sub]]</a>
+A *subscripting operator function* is a function named `operator[]` that
+is a non-static member function with exactly one parameter. For an
+expression of the form
 ``` bnf
 postfix-expression '[' expr-or-braced-init-list ']'
 ```
+the operator function is selected by overload resolution
+[[over.match.oper]]. If a member function is selected, the expression is
+interpreted as
+``` bnf
+postfix-expression . operator '['']' '(' expr-or-braced-init-list ')'
+```
 [*Example 1*:
 ``` cpp
 struct X {
 — *end example*]
 ### Class member access <a id="over.ref">[[over.ref]]</a>
+A *class member access operator function* is a function named
+`operator->` that is a non-static member function taking no parameters.
+For an expression of the form
 ``` bnf
+postfix-expression '->' templateₒₚₜ id-expression
 ```
+the operator function is selected by overload resolution
+[[over.match.oper]], and the expression is interpreted as
+``` bnf
+'(' postfix-expression . operator '->' '('')' ')' '->' templateₒₚₜ id-expression
+```
 ### Increment and decrement <a id="over.inc">[[over.inc]]</a>
+An *increment operator function* is a function named `operator++`. If
+this function is a non-static member function with no parameters, or a
+non-member function with one parameter, it 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.[^11]
 [*Example 1*:
 ``` cpp
 struct X {
 }
 ```
 — *end example*]
+A *decrement operator function* is a function named `operator\dcr` and
+is handled analogously to an increment operator function.

Diff to HTML by rtfpessoa