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

Files changed (1) hide show

tmp/tmpf9fsc4e2/{from.md → to.md} +68 -56

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

@@ -1,14 +1,16 @@
 ## Overloaded operators <a id="over.oper">[[over.oper]]</a>
-A function declaration having one of the following
-*operator-function-id*s as its name declares an *operator function*. A
-function template declaration having one of the following
-*operator-function-id*s as its name declares an *operator function
-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
 ```
@@ -64,26 +66,30 @@ 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]].
 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
@@ -96,25 +102,25 @@ 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 '@' '('')'
 ```
@@ -123,26 +129,26 @@ 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 ')'
@@ -217,69 +223,74 @@ void f() {
 — *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 {
   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>
 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
 ```
@@ -291,18 +302,19 @@ the operator function is selected by overload resolution
 ```
 ### 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 {
@@ -327,8 +339,8 @@ void f(X a, Y b) {
 }
 ```
 — *end example*]
-A *decrement operator function* is a function named `operator\dcr` and
-is handled analogously to an increment operator function.

 ## Overloaded operators <a id="over.oper">[[over.oper]]</a>
+### General <a id="over.oper.general">[[over.oper.general]]</a>
+A declaration whose *declarator-id* is an *operator-function-id* shall
+declare a function or function template or an explicit instantiation or
+specialization of a function template. A function so declared is an
+*operator function*. A function template so declared is an *operator
+function 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
 ```
 — *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 [[over.oper]] 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 [[over.oper]] do not
 apply to it unless explicitly stated in  [[expr.await]].
+An operator function shall either
+- be a member function or
+- be a non-member function that has at least one non-object 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
 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 [[over.oper]].
 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 non-object 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 '@' '('')'
 ```
 ``` bnf
 operator '@' '(' cast-expression ')'
 ```
+[*Note 1*: The operators `++` and `--` [[expr.pre.incr]] are described
+in  [[over.inc]]. — *end note*]
+[*Note 2*: The unary and binary forms of the same operator have the
+same name. 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>
+#### General <a id="over.binary.general">[[over.binary.general]]</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 non-object 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 ')'
 — *end note*]
 ### Function call <a id="over.call">[[over.call]]</a>
 A *function call operator function* is a function named `operator()`
+that is a 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 is selected, let e be the result of invoking the
+corresponding conversion operator function on the *postfix-expression*;
+the expression is interpreted as
 ``` bnf
+e '(' 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 member function named
+`operator[]` with an arbitrary number of parameters. It may have default
+arguments. For an expression of the form
 ``` bnf
+postfix-expression '[' expression-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 '['']' '(' expression-listₒₚₜ ')'
 ```
 [*Example 1*:
 ``` cpp
 struct X {
   Z operator[](std::initializer_list<int>);
+  Z operator[](auto...);
 };
 X x;
+x[{1,2,3}] = 7;                 // OK, meaning x.operator[]({1,2,3\)}
+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
+a[1,2,3] = 7;                   // error: built-in subscript operator
 ```
 — *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 non-object
+parameters. For an expression of the form
 ``` bnf
 postfix-expression '->' 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 non-object
+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 non-object 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.[^9]
 [*Example 1*:
 ``` cpp
 struct X {
 }
 ```
 — *end example*]
+A *decrement operator function* is a function named `operator--` and is
+handled analogously to an increment operator function.

Diff to HTML by rtfpessoa