[expr.unary.op] - C++17 → C++20

Files changed (1) hide show

tmp/tmpxhejdrp3/{from.md → to.md} +29 -34

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

@@ -1,36 +1,32 @@
-### Unary operators <a id="expr.unary.op">[[expr.unary.op]]</a>
 The unary `*` operator performs *indirection*: the expression to which
 it is applied shall be a pointer to an object type, or a pointer to a
 function type and the result is an lvalue referring to the object or
 function to which the expression points. If the type of the expression
 is “pointer to `T`”, the type of the result is “`T`”.
 [*Note 1*:  Indirection through a pointer to an incomplete type (other
-than *cv* `void`) is valid. The lvalue thus obtained can be used in
 limited ways (to initialize a reference, for example); this lvalue must
 not be converted to a prvalue, see  [[conv.lval]]. — *end note*]
 The result of each of the following unary operators is a prvalue.
-The result of the unary `&` operator is a pointer to its operand. The
-operand shall be an lvalue or a *qualified-id*. If the operand is a
-*qualified-id* naming a non-static or variant member `m` of some class
-`C` with type `T`, the result has type “pointer to member of class `C`
-of type `T`” and is a prvalue designating `C::m`. Otherwise, if the type
-of the expression is `T`, the result has type “pointer to `T`” and is a
-prvalue that is the address of the designated object ([[intro.memory]])
-or a pointer to the designated function.
-[*Note 2*: In particular, the address of an object of type “cv `T`” is
-“pointer to cv `T`”, with the same cv-qualification. — *end note*]
-For purposes of pointer arithmetic ([[expr.add]]) and comparison (
-[[expr.rel]], [[expr.eq]]), an object that is not an array element whose
-address is taken in this way is considered to belong to an array with
-one element of type `T`.
 [*Example 1*:
 ``` cpp
 struct A { int i; };
@@ -43,38 +39,37 @@ bool b = p2 > p1;   // defined behavior, with value true
 ```
 — *end example*]
 [*Note 3*: A pointer to member formed from a `mutable` non-static data
-member ([[dcl.stc]]) does not reflect the `mutable` specifier
-associated with the non-static data member. — *end note*]
 A pointer to member is only formed when an explicit `&` is used and its
 operand is a *qualified-id* not enclosed in parentheses.
 [*Note 4*: That is, the expression `&(qualified-id)`, where the
 *qualified-id* is enclosed in parentheses, does not form an expression
 of type “pointer to member”. Neither does `qualified-id`, because there
 is no implicit conversion from a *qualified-id* for a non-static member
 function to the type “pointer to member function” as there is from an
-lvalue of function type to the type “pointer to function” (
-[[conv.func]]). Nor is `&unqualified-id` a pointer to member, even
-within the scope of the *unqualified-id*’s class. — *end note*]
 If `&` is applied to an lvalue of incomplete class type and the complete
 type declares `operator&()`, it is unspecified whether the operator has
 the built-in meaning or the operator function is called. The operand of
 `&` shall not be a bit-field.
-The address of an overloaded function (Clause  [[over]]) can be taken
 only in a context that uniquely determines which version of the
-overloaded function is referred to (see  [[over.over]]).
-[*Note 5*: Since the context might determine whether the operand is a
-static or non-static member function, the context can also affect
-whether the expression has type “pointer to function” or “pointer to
-member function”. — *end note*]
 The operand of the unary `+` operator shall have arithmetic, unscoped
 enumeration, or pointer type and the result is the value of the
 argument. Integral promotion is performed on integral or enumeration
 operands. The type of the result is the type of the promoted operand.
@@ -85,22 +80,22 @@ promotion is performed on integral or enumeration operands. The negative
 of an unsigned quantity is computed by subtracting its value from 2ⁿ,
 where n is the number of bits in the promoted operand. The type of the
 result is the type of the promoted operand.
 The operand of the logical negation operator `!` is contextually
-converted to `bool` (Clause  [[conv]]); its value is `true` if the
-converted operand is `false` and `false` otherwise. The type of the
-result is `bool`.
 The operand of `~` shall have integral or unscoped enumeration type; the
 result is the ones’ complement of its operand. Integral promotions are
 performed. The type of the result is the type of the promoted operand.
 There is an ambiguity in the grammar when `~` is followed by a
-*class-name* or *decltype-specifier*. The ambiguity is resolved by
 treating `~` as the unary complement operator rather than as the start
 of an *unqualified-id* naming a destructor.
 [*Note 6*: Because the grammar does not permit an operator to follow
-the `.`, `->`, or `::` tokens, a `~` followed by a *class-name* or
 *decltype-specifier* in a member access expression or *qualified-id* is
 unambiguously parsed as a destructor name. — *end note*]

+#### Unary operators <a id="expr.unary.op">[[expr.unary.op]]</a>
 The unary `*` operator performs *indirection*: the expression to which
 it is applied shall be a pointer to an object type, or a pointer to a
 function type and the result is an lvalue referring to the object or
 function to which the expression points. If the type of the expression
 is “pointer to `T`”, the type of the result is “`T`”.
 [*Note 1*:  Indirection through a pointer to an incomplete type (other
+than cv `void`) is valid. The lvalue thus obtained can be used in
 limited ways (to initialize a reference, for example); this lvalue must
 not be converted to a prvalue, see  [[conv.lval]]. — *end note*]
 The result of each of the following unary operators is a prvalue.
+The result of the unary `&` operator is a pointer to its operand.
+- If the operand is a *qualified-id* naming a non-static or variant
+  member `m` of some class `C` with type `T`, the result has type
+  “pointer to member of class `C` of type `T`” and is a prvalue
+  designating `C::m`.
+- Otherwise, if the operand is an lvalue of type `T`, the resulting
+  expression is a prvalue of type “pointer to `T`” whose result is a
+  pointer to the designated object [[intro.memory]] or function.
+  \[*Note 2*: In particular, taking the address of a variable of type
+  “cv `T`” yields a pointer of type “pointer to cv `T`”. — *end note*]
+- Otherwise, the program is ill-formed.
 [*Example 1*:
 ``` cpp
 struct A { int i; };
 ```
 — *end example*]
 [*Note 3*: A pointer to member formed from a `mutable` non-static data
+member [[dcl.stc]] does not reflect the `mutable` specifier associated
+with the non-static data member. — *end note*]
 A pointer to member is only formed when an explicit `&` is used and its
 operand is a *qualified-id* not enclosed in parentheses.
 [*Note 4*: That is, the expression `&(qualified-id)`, where the
 *qualified-id* is enclosed in parentheses, does not form an expression
 of type “pointer to member”. Neither does `qualified-id`, because there
 is no implicit conversion from a *qualified-id* for a non-static member
 function to the type “pointer to member function” as there is from an
+lvalue of function type to the type “pointer to function” [[conv.func]].
+Nor is `&unqualified-id` a pointer to member, even within the scope of
+the *unqualified-id*’s class. — *end note*]
 If `&` is applied to an lvalue of incomplete class type and the complete
 type declares `operator&()`, it is unspecified whether the operator has
 the built-in meaning or the operator function is called. The operand of
 `&` shall not be a bit-field.
+[*Note 5*: The address of an overloaded function [[over]] can be taken
 only in a context that uniquely determines which version of the
+overloaded function is referred to (see  [[over.over]]). Since the
+context might determine whether the operand is a static or non-static
+member function, the context can also affect whether the expression has
+type “pointer to function” or “pointer to member
+function”. — *end note*]
 The operand of the unary `+` operator shall have arithmetic, unscoped
 enumeration, or pointer type and the result is the value of the
 argument. Integral promotion is performed on integral or enumeration
 operands. The type of the result is the type of the promoted operand.
 of an unsigned quantity is computed by subtracting its value from 2ⁿ,
 where n is the number of bits in the promoted operand. The type of the
 result is the type of the promoted operand.
 The operand of the logical negation operator `!` is contextually
+converted to `bool` [[conv]]; its value is `true` if the converted
+operand is `false` and `false` otherwise. The type of the result is
+`bool`.
 The operand of `~` shall have integral or unscoped enumeration type; the
 result is the ones’ complement of its operand. Integral promotions are
 performed. The type of the result is the type of the promoted operand.
 There is an ambiguity in the grammar when `~` is followed by a
+*type-name* or *decltype-specifier*. The ambiguity is resolved by
 treating `~` as the unary complement operator rather than as the start
 of an *unqualified-id* naming a destructor.
 [*Note 6*: Because the grammar does not permit an operator to follow
+the `.`, `->`, or `::` tokens, a `~` followed by a *type-name* or
 *decltype-specifier* in a member access expression or *qualified-id* is
 unambiguously parsed as a destructor name. — *end note*]

Diff to HTML by rtfpessoa