[expr.prop] - C++20 → C++23

Files changed (1) hide show

tmp/tmpsqbl49us/{from.md → to.md} +38 -38

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

@@ -8,18 +8,16 @@ Expressions are categorized according to the taxonomy in Figure
 <a id="fig:basic.lval"></a>
 ![Expression category taxonomy \[fig:basic.lval\]](images/valuecategories.svg)
 - A *glvalue* is an expression whose evaluation determines the identity
-  of an object, bit-field, or function.
 - A *prvalue* is an expression whose evaluation initializes an object or
- a bit-field, or computes the value of an operand of an operator, as
- specified by the context in which it appears, or an expression that
-  has type cv `void`.
-- An *xvalue* is a glvalue that denotes an object or bit-field whose
-  resources can be reused (usually because it is near the end of its
-  lifetime).
 - An *lvalue* is a glvalue that is not an xvalue.
 - An *rvalue* is a prvalue or an xvalue.
 Every expression belongs to exactly one of the fundamental
 classifications in this taxonomy: lvalue, xvalue, or prvalue. This
@@ -43,15 +41,15 @@ values. — *end note*]
 [*Note 3*:
 An expression is an xvalue if it is:
 - the result of calling a function, whether implicitly or explicitly,
   whose return type is an rvalue reference to object type [[expr.call]],
-- a cast to an rvalue reference to object type ([[expr.type.conv]],
-  [[expr.dynamic.cast]], [[expr.static.cast]] [[expr.reinterpret.cast]],
-  [[expr.const.cast]], [[expr.cast]]),
 - a subscripting operation with an xvalue array operand [[expr.sub]],
 - a class member access expression designating a non-static data member
   of non-reference type in which the object expression is an xvalue
   [[expr.ref]], or
 - a `.*` pointer-to-member expression in which the first operand is an
@@ -121,26 +119,26 @@ glvalue for that operand, the temporary materialization conversion
 The discussion of reference initialization in  [[dcl.init.ref]] and of
 temporaries in  [[class.temporary]] indicates the behavior of lvalues
 and rvalues in other significant contexts.
-Unless otherwise indicated [[dcl.type.simple]], a prvalue shall always
 have complete type or the `void` type; if it has a class type or
-(possibly multi-dimensional) array of class type, that class shall not
-be an abstract class [[class.abstract]]. A glvalue shall not have type
 cv `void`.
-[*Note 8*: A glvalue may have complete or incomplete non-`void` type.
 Class and array prvalues can have cv-qualified types; other prvalues
 always have cv-unqualified types. See [[expr.type]]. — *end note*]
 An lvalue is *modifiable* unless its type is const-qualified or is a
 function type.
 [*Note 9*: A program that attempts to modify an object through a
-nonmodifiable lvalue or through an rvalue is ill-formed ([[expr.ass]],
-[[expr.post.incr]], [[expr.pre.incr]]). — *end note*]
 If a program attempts to access [[defns.access]] the stored value of an
 object through a glvalue whose type is not similar [[conv.qual]] to one
 of the following types the behavior is undefined:[^4]
@@ -152,17 +150,18 @@ of the following types the behavior is undefined:[^4]
 If a program invokes a defaulted copy/move constructor or copy/move
 assignment operator for a union of type `U` with a glvalue argument that
 does not denote an object of type cv `U` within its lifetime, the
 behavior is undefined.
-[*Note 10*: Unlike in C, C++ has no accesses of class
-type. — *end note*]
 ### Type <a id="expr.type">[[expr.type]]</a>
-If an expression initially has the type “reference to `T`” (
-[[dcl.ref]], [[dcl.init.ref]]), the type is adjusted to `T` prior to any
 further analysis. The expression designates the object or function
 denoted by the reference, and the expression is an lvalue or an xvalue,
 depending on the expression.
 [*Note 1*: Before the lifetime of the reference has started or after it
@@ -187,26 +186,27 @@ pointer-to-member type or `std::nullptr_t`, is:
 - if `T1` or `T2` is “pointer to `noexcept` function” and the other type
   is “pointer to function”, where the function types are otherwise the
   same, “pointer to function”;
 - if `T1` is “pointer to *cv1* `C1`” and `T2` is “pointer to *cv2*
   `C2`”, where `C1` is reference-related to `C2` or `C2` is
-  reference-related to `C1` [[dcl.init.ref]], the cv-combined type
-  [[conv.qual]] of `T1` and `T2` or the cv-combined type of `T2` and
-  `T1`, respectively;
 - if `T1` or `T2` is “pointer to member of `C1` of type function”, the
   other type is “pointer to member of `C2` of type `noexcept` function”,
   and `C1` is reference-related to `C2` or `C2` is reference-related to
   `C1` [[dcl.init.ref]], where the function types are otherwise the
   same, “pointer to member of `C2` of type function” or “pointer to
   member of `C1` of type function”, respectively;
 - if `T1` is “pointer to member of `C1` of type *cv1* `U`” and `T2` is
   “pointer to member of `C2` of type *cv2* `U`”, for some non-function
   type `U`, where `C1` is reference-related to `C2` or `C2` is
-  reference-related to `C1` [[dcl.init.ref]], the cv-combined type of
-  `T2` and `T1` or the cv-combined type of `T1` and `T2`, respectively;
-- if `T1` and `T2` are similar types [[conv.qual]], the cv-combined type
-  of `T1` and `T2`;
 - otherwise, a program that necessitates the determination of a
   composite pointer type is ill-formed.
 [*Example 1*:
@@ -223,16 +223,15 @@ pointer to `const int`”.
 — *end example*]
 ### Context dependence <a id="expr.context">[[expr.context]]</a>
-In some contexts, *unevaluated operands* appear ([[expr.prim.req]],
-[[expr.typeid]], [[expr.sizeof]], [[expr.unary.noexcept]],
-[[dcl.type.simple]], [[temp.pre]], [[temp.concept]]). An unevaluated
-operand is not evaluated.
-[*Note 1*: In an unevaluated operand, a non-static class member may be
 named [[expr.prim.id]] and naming of objects or functions does not, by
 itself, require that a definition be provided [[basic.def.odr]]. An
 unevaluated operand is considered a full-expression
 [[intro.execution]]. — *end note*]
@@ -255,14 +254,15 @@ volatile-qualified type and it is one of the following:
   these expressions.
 [*Note 2*: Using an overloaded operator causes a function call; the
 above covers only operators with built-in meaning. — *end note*]
-If the (possibly converted) expression is a prvalue, the temporary
-materialization conversion [[conv.rval]] is applied.
-[*Note 3*: If the expression is an lvalue of class type, it must have a
-volatile copy constructor to initialize the temporary object that is the
-result object of the lvalue-to-rvalue conversion. — *end note*]
-The glvalue expression is evaluated and its value is discarded.

 <a id="fig:basic.lval"></a>
 ![Expression category taxonomy \[fig:basic.lval\]](images/valuecategories.svg)
 - A *glvalue* is an expression whose evaluation determines the identity
+  of an object or function.
 - A *prvalue* is an expression whose evaluation initializes an object or
+  computes the value of an operand of an operator, as specified by the
+  context in which it appears, or an expression that has type cv `void`.
+- An *xvalue* is a glvalue that denotes an object whose resources can be
+  reused (usually because it is near the end of its lifetime).
 - An *lvalue* is a glvalue that is not an xvalue.
 - An *rvalue* is a prvalue or an xvalue.
 Every expression belongs to exactly one of the fundamental
 classifications in this taxonomy: lvalue, xvalue, or prvalue. This
 [*Note 3*:
 An expression is an xvalue if it is:
+- a move-eligible *id-expression* [[expr.prim.id.unqual]],
 - the result of calling a function, whether implicitly or explicitly,
   whose return type is an rvalue reference to object type [[expr.call]],
+- a cast to an rvalue reference to object type
+  [[expr.type.conv]], [[expr.dynamic.cast]], [[expr.static.cast]], [[expr.reinterpret.cast]], [[expr.const.cast]], [[expr.cast]],
 - a subscripting operation with an xvalue array operand [[expr.sub]],
 - a class member access expression designating a non-static data member
   of non-reference type in which the object expression is an xvalue
   [[expr.ref]], or
 - a `.*` pointer-to-member expression in which the first operand is an
 The discussion of reference initialization in  [[dcl.init.ref]] and of
 temporaries in  [[class.temporary]] indicates the behavior of lvalues
 and rvalues in other significant contexts.
+Unless otherwise indicated [[dcl.type.decltype]], a prvalue shall always
 have complete type or the `void` type; if it has a class type or
+(possibly multidimensional) array of class type, that class shall not be
+an abstract class [[class.abstract]]. A glvalue shall not have type
 cv `void`.
+[*Note 8*: A glvalue can have complete or incomplete non-`void` type.
 Class and array prvalues can have cv-qualified types; other prvalues
 always have cv-unqualified types. See [[expr.type]]. — *end note*]
 An lvalue is *modifiable* unless its type is const-qualified or is a
 function type.
 [*Note 9*: A program that attempts to modify an object through a
+nonmodifiable lvalue or through an rvalue is ill-formed
+[[expr.ass]], [[expr.post.incr]], [[expr.pre.incr]]. — *end note*]
 If a program attempts to access [[defns.access]] the stored value of an
 object through a glvalue whose type is not similar [[conv.qual]] to one
 of the following types the behavior is undefined:[^4]
 If a program invokes a defaulted copy/move constructor or copy/move
 assignment operator for a union of type `U` with a glvalue argument that
 does not denote an object of type cv `U` within its lifetime, the
 behavior is undefined.
+[*Note 10*: In C, an entire object of structure type can be accessed,
+e.g., using assignment. By contrast, C++ has no notion of accessing an
+object of class type through an lvalue of class type. — *end note*]
 ### Type <a id="expr.type">[[expr.type]]</a>
+If an expression initially has the type “reference to `T`”
+[[dcl.ref]], [[dcl.init.ref]], the type is adjusted to `T` prior to any
 further analysis. The expression designates the object or function
 denoted by the reference, and the expression is an lvalue or an xvalue,
 depending on the expression.
 [*Note 1*: Before the lifetime of the reference has started or after it
 - if `T1` or `T2` is “pointer to `noexcept` function” and the other type
   is “pointer to function”, where the function types are otherwise the
   same, “pointer to function”;
 - if `T1` is “pointer to *cv1* `C1`” and `T2` is “pointer to *cv2*
   `C2`”, where `C1` is reference-related to `C2` or `C2` is
+  reference-related to `C1` [[dcl.init.ref]], the qualification-combined
+ type [[conv.qual]] of `T1` and `T2` or the qualification-combined type
+ of `T2` and `T1`, respectively;
 - if `T1` or `T2` is “pointer to member of `C1` of type function”, the
   other type is “pointer to member of `C2` of type `noexcept` function”,
   and `C1` is reference-related to `C2` or `C2` is reference-related to
   `C1` [[dcl.init.ref]], where the function types are otherwise the
   same, “pointer to member of `C2` of type function” or “pointer to
   member of `C1` of type function”, respectively;
 - if `T1` is “pointer to member of `C1` of type *cv1* `U`” and `T2` is
   “pointer to member of `C2` of type *cv2* `U`”, for some non-function
   type `U`, where `C1` is reference-related to `C2` or `C2` is
+  reference-related to `C1` [[dcl.init.ref]], the qualification-combined
+ type of `T2` and `T1` or the qualification-combined type of `T1` and
+ `T2`, respectively;
+- if `T1` and `T2` are similar types [[conv.qual]], the
+  qualification-combined type of `T1` and `T2`;
 - otherwise, a program that necessitates the determination of a
   composite pointer type is ill-formed.
 [*Example 1*:
 — *end example*]
 ### Context dependence <a id="expr.context">[[expr.context]]</a>
+In some contexts, *unevaluated operands* appear
+[[expr.prim.req]], [[expr.typeid]], [[expr.sizeof]], [[expr.unary.noexcept]], [[dcl.type.decltype]], [[temp.pre]], [[temp.concept]].
+An unevaluated operand is not evaluated.
+[*Note 1*: In an unevaluated operand, a non-static class member can be
 named [[expr.prim.id]] and naming of objects or functions does not, by
 itself, require that a definition be provided [[basic.def.odr]]. An
 unevaluated operand is considered a full-expression
 [[intro.execution]]. — *end note*]
   these expressions.
 [*Note 2*: Using an overloaded operator causes a function call; the
 above covers only operators with built-in meaning. — *end note*]
+The temporary materialization conversion [[conv.rval]] is applied if the
+(possibly converted) expression is a prvalue of object type.
+[*Note 3*: If the original expression is an lvalue of class type, it
+must have a volatile copy constructor to initialize the temporary object
+that is the result object of the temporary materialization
+conversion. — *end note*]
+The expression is evaluated and its result (if any) is discarded.

Diff to HTML by rtfpessoa