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

Files changed (1) hide show

tmp/tmpxom9q95g/{from.md → to.md} +268 -0

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

	@@ -0,0 +1,268 @@

+## Properties of expressions <a id="expr.prop">[[expr.prop]]</a>
+### Value category <a id="basic.lval">[[basic.lval]]</a>
+Expressions are categorized according to the taxonomy in Figure
+[[fig:basic.lval]].
+<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
+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
+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*]
+[*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:
+- 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
+  xvalue and the second operand is a pointer to data member
+  [[expr.mptr.oper]].
+In general, the effect of this rule is that named rvalue references are
+treated as lvalues and unnamed rvalue references to objects are treated
+as xvalues; rvalue references to functions are treated as lvalues
+whether named or not.
+— *end note*]
+[*Example 1*:
+``` cpp
+struct A {
+  int m;
+};
+A&& operator+(A, A);
+A&& f();
+A a;
+A&& ar = static_cast<A&&>(a);
+```
+The expressions `f()`, `f().m`, `static_cast<A&&>(a)`, and `a + a` are
+xvalues. The expression `ar` is an lvalue.
+— *end example*]
+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
+such a context; see  [[dcl.init.ref]]. — *end note*]
+[*Note 6*: Because cv-qualifiers are removed from the type of an
+expression of non-class type when the expression is converted to a
+prvalue, an lvalue of type `const int` can, for example, be used where a
+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.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]
+- 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*: 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
+has ended, the behavior is undefined (see
+[[basic.life]]). — *end note*]
+If a prvalue initially has the type “cv `T`”, where `T` is a
+cv-unqualified non-class, non-array type, the type of the expression is
+adjusted to `T` prior to any further analysis.
+The *composite pointer type* of two operands `p1` and `p2` having types
+`T1` and `T2`, respectively, where at least one is a pointer or
+pointer-to-member type or `std::nullptr_t`, is:
+- if both `p1` and `p2` are null pointer constants, `std::nullptr_t`;
+- if either `p1` or `p2` is a null pointer constant, `T2` or `T1`,
+  respectively;
+- if `T1` or `T2` is “pointer to *cv1* `void`” and the other type is
+  “pointer to *cv2* `T`”, where `T` is an object type or `void`,
+  “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 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*:
+``` cpp
+typedef void *p;
+typedef const int *q;
+typedef int **pi;
+typedef const int **pci;
+```
+The composite pointer type of `p` and `q` is “pointer to `const void`”;
+the composite pointer type of `pi` and `pci` is “pointer to `const`
+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*]
+In some contexts, an expression only appears for its side effects. Such
+an expression is called a *discarded-value expression*. The
+array-to-pointer [[conv.array]] and function-to-pointer [[conv.func]]
+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
+  third operands are one of these expressions, or
+- comma expression [[expr.comma]] where the right operand is one of
+  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.

Diff to HTML by rtfpessoa