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

Files changed (1) hide show

tmp/tmpewctjrhy/{from.md → to.md} +47 -39

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

@@ -8,22 +8,22 @@ 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 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
-property of an expression is called its *value category*.
 [*Note 1*: The discussion of each built-in operator in
 [[expr.compound]] indicates the category of the value it yields and the
 value categories of the operands it expects. For example, the built-in
 assignment operators expect that the left operand is an lvalue and that
@@ -34,18 +34,19 @@ types. — *end note*]
 [*Note 2*: Historically, lvalues and rvalues were so-called because
 they could appear on the left- and right-hand side of an assignment
 (although this is no longer generally true); glvalues are “generalized”
 lvalues, prvalues are “pure” rvalues, and xvalues are “eXpiring”
-lvalues. Despite their names, these terms classify expressions, not
 values. — *end note*]
 [*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]],
@@ -84,21 +85,18 @@ xvalues. The expression `ar` is an lvalue.
 The *result* of a glvalue is the entity denoted by the expression. The
 *result* of a prvalue is the value that the expression stores into its
 context; a prvalue that has type cv `void` has no result. A prvalue
 whose result is the value *V* is sometimes said to have or name the
 value *V*. The *result object* of a prvalue is the object initialized by
-the prvalue; a non-discarded prvalue that is used to compute the value
-of an operand of a built-in operator or a prvalue that has type
-cv `void` has no result object.
 [*Note 4*: Except when the prvalue is the operand of a
-*decltype-specifier*, a prvalue of class or array type always has a
-result object. For a discarded prvalue that has type other than
-cv `void`, a temporary object is materialized; see
-[[expr.context]]. — *end note*]
-Whenever a glvalue appears as an operand of an operator that expects a
 prvalue for that operand, the lvalue-to-rvalue [[conv.lval]],
 array-to-pointer [[conv.array]], or function-to-pointer [[conv.func]]
 standard conversions are applied to convert the expression to a prvalue.
 [*Note 5*: An attempt to bind an rvalue reference to an lvalue is not
@@ -111,60 +109,69 @@ prvalue of type `int` is required. — *end note*]
 [*Note 7*: There are no prvalue bit-fields; if a bit-field is converted
 to a prvalue [[conv.lval]], a prvalue of the type of the bit-field is
 created, which might then be promoted [[conv.prom]]. — *end note*]
-Whenever a prvalue appears as an operand of an operator that expects a
-glvalue for that operand, the temporary materialization conversion
-[[conv.rval]] is applied to convert the expression to an xvalue.
-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]
-- the dynamic type of the object,
-- a type that is the signed or unsigned type corresponding to the
- dynamic type of the object, or
 - a `char`, `unsigned char`, or `std::byte` type.
 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
 has ended, the behavior is undefined (see
 [[basic.life]]). — *end note*]
@@ -184,15 +191,15 @@ pointer-to-member type or `std::nullptr_t`, is:
   “pointer to *cv12* `void`”, where *cv12* is the union of *cv1* and
   *cv2*;
 - 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
@@ -224,11 +231,11 @@ 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.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
@@ -242,10 +249,11 @@ standard conversions are not applied. The lvalue-to-rvalue conversion
 [[conv.lval]] is applied if and only if the expression is a glvalue of
 volatile-qualified type and it is one of the following:
 - `(` *expression* `)`, where *expression* is one of these expressions,
 - *id-expression* [[expr.prim.id]],
 - subscripting [[expr.sub]],
 - class member access [[expr.ref]],
 - indirection [[expr.unary.op]],
 - pointer-to-member operation [[expr.mptr.oper]],
 - conditional expression [[expr.cond]] where both the second and the

 <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, function, or non-static data member.
 - 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 categories in
+this taxonomy: lvalue, xvalue, or prvalue. This property of an
+expression is called its *value category*.
 [*Note 1*: The discussion of each built-in operator in
 [[expr.compound]] indicates the category of the value it yields and the
 value categories of the operands it expects. For example, the built-in
 assignment operators expect that the left operand is an lvalue and that
 [*Note 2*: Historically, lvalues and rvalues were so-called because
 they could appear on the left- and right-hand side of an assignment
 (although this is no longer generally true); glvalues are “generalized”
 lvalues, prvalues are “pure” rvalues, and xvalues are “eXpiring”
+lvalues. Despite their names, these terms apply to expressions, not
 values. — *end note*]
 [*Note 3*:
 An expression is an xvalue if it is:
+- a move-eligible *id-expression* [[expr.prim.id.unqual]] or
+  *splice-expression* [[expr.prim.splice]],
 - 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]],
 The *result* of a glvalue is the entity denoted by the expression. The
 *result* of a prvalue is the value that the expression stores into its
 context; a prvalue that has type cv `void` has no result. A prvalue
 whose result is the value *V* is sometimes said to have or name the
 value *V*. The *result object* of a prvalue is the object initialized by
+the prvalue; a prvalue that has type cv `void` has no result object.
 [*Note 4*: Except when the prvalue is the operand of a
+*decltype-specifier*, a prvalue of object type always has a result
+object. For a discarded prvalue that has type other than cv `void`, a
+temporary object is materialized; see [[expr.context]]. — *end note*]
+Whenever a glvalue appears as an operand of an operator that requires a
 prvalue for that operand, the lvalue-to-rvalue [[conv.lval]],
 array-to-pointer [[conv.array]], or function-to-pointer [[conv.func]]
 standard conversions are applied to convert the expression to a prvalue.
 [*Note 5*: An attempt to bind an rvalue reference to an lvalue is not
 [*Note 7*: There are no prvalue bit-fields; if a bit-field is converted
 to a prvalue [[conv.lval]], a prvalue of the type of the bit-field is
 created, which might then be promoted [[conv.prom]]. — *end note*]
+Unless otherwise specified
+[[expr.reinterpret.cast]], [[expr.const.cast]], whenever a prvalue that
+is not the result of the lvalue-to-rvalue conversion [[conv.lval]]
+appears as an operand of an operator, the temporary materialization
+conversion [[conv.rval]] is applied to convert the expression to an
+xvalue.
+[*Note 8*: 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. — *end note*]
 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 9*: 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 10*: A program that attempts to modify an object through a
 nonmodifiable lvalue or through an rvalue is ill-formed
+[[expr.assign]], [[expr.post.incr]], [[expr.pre.incr]]. — *end note*]
+An object of dynamic type `T`_obj is *type-accessible* through a glvalue
+of type `T`_ref if `T`_ref is similar [[conv.qual]] to:
+- `T`_obj,
+- a type that is the signed or unsigned type corresponding to `T`_obj,
+  or
 - a `char`, `unsigned char`, or `std::byte` type.
+If a program attempts to access [[defns.access]] the stored value of an
+object through a glvalue through which it is not type-accessible, 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 11*: 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 value category of the expression is not altered.
+Let X be the object or function denoted by the reference. If a pointer
+to X would be valid in the context of the evaluation of the expression
+[[basic.fundamental]], the result designates X; otherwise, the behavior
+is undefined.
 [*Note 1*: Before the lifetime of the reference has started or after it
 has ended, the behavior is undefined (see
 [[basic.life]]). — *end note*]
   “pointer to *cv12* `void`”, where *cv12* is the union of *cv1* and
   *cv2*;
 - 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 `C1`” and `T2` is “pointer to `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
 — *end example*]
 ### Context dependence <a id="expr.context">[[expr.context]]</a>
 In some contexts, *unevaluated operands* appear
+[[expr.prim.req.simple]], [[expr.prim.req.compound]], [[expr.typeid]], [[expr.sizeof]], [[expr.unary.noexcept]], [[expr.reflect]], [[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
 [[conv.lval]] is applied if and only if the expression is a glvalue of
 volatile-qualified type and it is one of the following:
 - `(` *expression* `)`, where *expression* is one of these expressions,
 - *id-expression* [[expr.prim.id]],
+- *splice-expression* [[expr.prim.splice]],
 - subscripting [[expr.sub]],
 - class member access [[expr.ref]],
 - indirection [[expr.unary.op]],
 - pointer-to-member operation [[expr.mptr.oper]],
 - conditional expression [[expr.cond]] where both the second and the

Diff to HTML by rtfpessoa