[basic.lval] - C++14 → C++17

Files changed (1) hide show

tmp/tmpfv4kzi5s/{from.md → to.md} +71 -59

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

@@ -5,82 +5,94 @@ Expressions are categorized according to the taxonomy in Figure
 <a id="fig:categories"></a>
 ![Expression category taxonomy \[fig:categories\]](images/valuecategories.svg)
-- An *lvalue* (so called, historically, because lvalues could appear on
- the left-hand side of an assignment expression) designates a function
-  or an object. If `E` is an expression of pointer type, then `*E` is an
- lvalue expression referring to the object or function to which `E`
- points. As another example, the result of calling a function whose
-  return type is an lvalue reference is an lvalue.
-- An *xvalue* (an “eXpiring” value) also refers to an object, usually
- near the end of its lifetime (so that its resources may be moved, for
- example). An xvalue is the result of certain kinds of expressions
- involving rvalue references ([[dcl.ref]]). The result of calling a
- function whose return type is an rvalue reference to an object type is
- an xvalue ([[expr.call]]).
-- A *glvalue* (“generalized” lvalue) is an lvalue or an xvalue.
-- An *rvalue* (so called, historically, because rvalues could appear on
-  the right-hand side of an assignment expression) is an xvalue, a
-  temporary object ([[class.temporary]]) or subobject thereof, or a
-  value that is not associated with an object.
-- A *prvalue* (“pure” rvalue) is an rvalue that is not an xvalue. The
-  result of calling a function whose return type is not a reference is a
-  prvalue. The value of a literal such as `12`, `7.3e5`, or `true` is
-  also a prvalue.
 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*. The discussion
-of each built-in operator in Clause  [[expr]] 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 the right operand is a prvalue and yield
-an lvalue as the result. User-defined operators are functions, and the
-categories of values they expect and yield are determined by their
-parameter and return types.
-Whenever a glvalue appears in a context where a prvalue is expected, the
-glvalue is converted to a prvalue; see  [[conv.lval]], [[conv.array]],
-and  [[conv.func]]. An attempt to bind an rvalue reference to an lvalue
-is not such a context; see  [[dcl.init.ref]].
 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 ([[expr.call]]), prvalues shall always have
-complete types or the `void` type; in addition to these types, glvalues
-can also have incomplete types. class and array prvalues can have
-cv-qualified types; other prvalues always have cv-unqualified types. See
-Clause  [[expr]].
-An lvalue for an object is necessary in order to modify the object
-except that an rvalue of class type can also be used to modify its
-referent under certain circumstances. a member function called for an
-object ([[class.mfct]]) can modify the object.
-Functions cannot be modified, but pointers to functions can be
-modifiable.
-A pointer to an incomplete type can be modifiable. At some point in the
-program when the pointed to type is complete, the object at which the
-pointer points can also be modified.
-The referent of a `const`-qualified expression shall not be modified
-(through that expression), except that if it is of class type and has a
-`mutable` component, that component can be modified ([[dcl.type.cv]]).
-If an expression can be used to modify the object to which it refers,
-the expression is called *modifiable*. A program that attempts to modify
-an object through a nonmodifiable lvalue or rvalue expression is
-ill-formed.
 If a program attempts to access the stored value of an object through a
 glvalue of other than one of the following types the behavior is
-undefined:[^30]
 - the dynamic type of the object,
 - a cv-qualified version of the dynamic type of the object,
 - a type similar (as defined in  [[conv.qual]]) to the dynamic type of
   the object,
@@ -92,7 +104,7 @@ undefined:[^30]
   types among its elements or non-static data members (including,
   recursively, an element or non-static data member of a subaggregate or
   contained union),
 - a type that is a (possibly cv-qualified) base class type of the
   dynamic type of the object,
-- a `char` or `unsigned` `char` type.

 <a id="fig:categories"></a>
 ![Expression category taxonomy \[fig:categories\]](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 the operand of an operator, as
+ specified by the context in which it appears.
+- 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). \[*Example 1*: Certain kinds of expressions involving
+ rvalue references ([[dcl.ref]]) yield xvalues, such as a call to a
+ function whose return type is an rvalue reference or a cast to an
+  rvalue reference type. — *end example*]
+- An *lvalue* is a glvalue that is not an xvalue.
+- An *rvalue* is a prvalue or an xvalue.
+[*Note 1*: 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*]
 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 2*: The discussion of each built-in operator in Clause  [[expr]]
+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 the right
+operand is a prvalue and yield an lvalue as the result. User-defined
+operators are functions, and the categories of values they expect and
+yield are determined by their parameter and return types. — *end note*]
+The *result* of a prvalue is the value that the expression stores into
+its context. 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 is used to compute the
+value of an operand of an operator or that has type cv `void` has no
+result object.
+[*Note 3*: 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, a temporary object is
+materialized; see Clause  [[expr]]. — *end note*]
+The *result* of a glvalue is the entity denoted by the expression.
+[*Note 4*: Whenever a glvalue appears in a context where a prvalue is
+expected, the glvalue is converted to a prvalue; see  [[conv.lval]],
+[[conv.array]], and  [[conv.func]]. An attempt to bind an rvalue
+reference to an lvalue is not such a context; see
+[[dcl.init.ref]]. — *end note*]
+[*Note 5*: 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*]
+[*Note 6*: Whenever a prvalue appears in a context where a glvalue is
+expected, the prvalue is converted to an xvalue; see
+[[conv.rval]]. — *end note*]
 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 ([[expr.call]]), a prvalue shall always have
+complete type or the `void` type. A glvalue shall not have type
+cv `void`.
+[*Note 7*: 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 Clause  [[expr]]. — *end note*]
+An lvalue is *modifiable* unless its type is const-qualified or is a
+function type.
+[*Note 8*: A program that attempts to modify an object through a
+nonmodifiable lvalue expression or through an rvalue expression is
+ill-formed ([[expr.ass]], [[expr.post.incr]],
+[[expr.pre.incr]]). — *end note*]
 If a program attempts to access the stored value of an object through a
 glvalue of other than one of the following types the behavior is
+undefined:[^31]
 - the dynamic type of the object,
 - a cv-qualified version of the dynamic type of the object,
 - a type similar (as defined in  [[conv.qual]]) to the dynamic type of
   the object,
   types among its elements or non-static data members (including,
   recursively, an element or non-static data member of a subaggregate or
   contained union),
 - a type that is a (possibly cv-qualified) base class type of the
   dynamic type of the object,
+- a `char`, `unsigned char`, or `std::byte` type.

Diff to HTML by rtfpessoa