[intro.execution] - C++23 → Trunk

Files changed (1) hide show

tmp/tmpvupw5e_z/{from.md → to.md} +60 -27

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

@@ -62,16 +62,18 @@ or *initializer* E are
 A *full-expression* is
 - an unevaluated operand [[expr.context]],
 - a *constant-expression* [[expr.const]],
 - an immediate invocation [[expr.const]],
-- an *init-declarator* [[dcl.decl]] or a *mem-initializer*
   [[class.base.init]], including the constituent expressions of the
   initializer,
 - an invocation of a destructor generated at the end of the lifetime of
   an object other than a temporary object [[class.temporary]] whose
-  lifetime has not been extended, or
 - an expression that is not a subexpression of another expression and
   that is not otherwise part of a full-expression.
 If a language construct is defined to produce an implicit call of a
 function, a use of the language construct is considered to be an
@@ -98,11 +100,11 @@ S s1(1);                        // full-expression comprises call of S::S(int)
 void f() {
   S s2 = 2;                     // full-expression comprises call of S::S(int)
   if (S(3).v())                 // full-expression includes lvalue-to-rvalue and int to bool conversions,
                                 // performed before temporary is deleted at end of full-expression
   { }
-  bool b = noexcept(S()); // exception specification of destructor of S considered for noexcept
   // full-expression is destruction of s2 at end of block
 }
 struct B {
   B(S = S(0));
@@ -119,19 +121,20 @@ full-expression. For example, subexpressions involved in evaluating
 default arguments [[dcl.fct.default]] are considered to be created in
 the expression that calls the function, not the expression that defines
 the default argument. — *end note*]
 Reading an object designated by a `volatile` glvalue [[basic.lval]],
-modifying an object, calling a library I/O function, or calling a
-function that does any of those operations are all *side effects*, which
-are changes in the state of the execution environment. *Evaluation* of
-an expression (or a subexpression) in general includes both value
 computations (including determining the identity of an object for
 glvalue evaluation and fetching a value previously assigned to an object
 for prvalue evaluation) and initiation of side effects. When a call to a
 library I/O function returns or an access through a volatile glvalue is
-evaluated the side effect is considered complete, even though some
 external actions implied by the call (such as the I/O itself) or by the
 `volatile` access may not have completed yet.
 *Sequenced before* is an asymmetric, transitive, pair-wise relation
 between evaluations executed by a single thread [[intro.multithread]],
@@ -156,29 +159,43 @@ every value computation and every side effect associated with the
 expression *X* is sequenced before every value computation and every
 side effect associated with the expression *Y*.
 Every value computation and side effect associated with a
 full-expression is sequenced before every value computation and side
-effect associated with the next full-expression to be evaluated.[^22]
 Except where noted, evaluations of operands of individual operators and
 of subexpressions of individual expressions are unsequenced.
 [*Note 5*: In an expression that is evaluated more than once during the
 execution of a program, unsequenced and indeterminately sequenced
 evaluations of its subexpressions need not be performed consistently in
 different evaluations. — *end note*]
 The value computations of the operands of an operator are sequenced
-before the value computation of the result of the operator. If a side
-effect on a memory location [[intro.memory]] is unsequenced relative to
-either another side effect on the same memory location or a value
-computation using the value of any object in the same memory location,
-and they are not potentially concurrent [[intro.multithread]], the
-behavior is undefined.
-[*Note 6*: The next subclause imposes similar, but more complex
 restrictions on potentially concurrent computations. — *end note*]
 [*Example 3*:
 ``` cpp
@@ -186,24 +203,35 @@ void g(int i) {
   i = 7, i++, i++;              // i becomes 9
   i = i++ + 1;                  // the value of i is incremented
   i = i++ + i;                  // undefined behavior
   i = i + 1;                    // the value of i is incremented
 }
 ```
 — *end example*]
-When invoking a function (whether or not the function is inline), every
-argument expression and the postfix expression designating the called
-function are sequenced before every expression or statement in the body
-of the called function. For each function invocation or evaluation of an
-*await-expression* *F*, each evaluation that does not occur within *F*
-but is evaluated on the same thread and as part of the same signal
-handler (if any) is either sequenced before all evaluations that occur
-within *F* or sequenced after all evaluations that occur within
-*F*;[^23]
 if *F* invokes or resumes a coroutine [[expr.await]], only evaluations
 subsequent to the previous suspension (if any) and prior to the next
 suspension (if any) are considered to occur within *F*.
@@ -222,9 +250,14 @@ regardless of the syntax of the expression that calls the function.
 If a signal handler is executed as a result of a call to the
 `std::raise` function, then the execution of the handler is sequenced
 after the invocation of the `std::raise` function and before its return.
-[*Note 7*: When a signal is received for another reason, the execution
 of the signal handler is usually unsequenced with respect to the rest of
 the program. — *end note*]

 A *full-expression* is
 - an unevaluated operand [[expr.context]],
 - a *constant-expression* [[expr.const]],
 - an immediate invocation [[expr.const]],
+- an *init-declarator* [[dcl.decl]] (including such introduced by a
+  structured binding [[dcl.struct.bind]]) or a *mem-initializer*
   [[class.base.init]], including the constituent expressions of the
   initializer,
 - an invocation of a destructor generated at the end of the lifetime of
   an object other than a temporary object [[class.temporary]] whose
+  lifetime has not been extended,
+- the predicate of a contract assertion [[basic.contract]], or
 - an expression that is not a subexpression of another expression and
   that is not otherwise part of a full-expression.
 If a language construct is defined to produce an implicit call of a
 function, a use of the language construct is considered to be an
 void f() {
   S s2 = 2;                     // full-expression comprises call of S::S(int)
   if (S(3).v())                 // full-expression includes lvalue-to-rvalue and int to bool conversions,
                                 // performed before temporary is deleted at end of full-expression
   { }
+  bool b = noexcept(S(4)); // exception specification of destructor of S considered for noexcept
   // full-expression is destruction of s2 at end of block
 }
 struct B {
   B(S = S(0));
 default arguments [[dcl.fct.default]] are considered to be created in
 the expression that calls the function, not the expression that defines
 the default argument. — *end note*]
 Reading an object designated by a `volatile` glvalue [[basic.lval]],
+modifying an object, producing an injected declaration [[expr.const]],
+calling a library I/O function, or calling a function that does any of
+those operations are all *side effects*, which are changes in the state
+of the execution or translation environment. *Evaluation* of an
+expression (or a subexpression) in general includes both value
 computations (including determining the identity of an object for
 glvalue evaluation and fetching a value previously assigned to an object
 for prvalue evaluation) and initiation of side effects. When a call to a
 library I/O function returns or an access through a volatile glvalue is
+evaluated, the side effect is considered complete, even though some
 external actions implied by the call (such as the I/O itself) or by the
 `volatile` access may not have completed yet.
 *Sequenced before* is an asymmetric, transitive, pair-wise relation
 between evaluations executed by a single thread [[intro.multithread]],
 expression *X* is sequenced before every value computation and every
 side effect associated with the expression *Y*.
 Every value computation and side effect associated with a
 full-expression is sequenced before every value computation and side
+effect associated with the next full-expression to be evaluated.[^21]
 Except where noted, evaluations of operands of individual operators and
 of subexpressions of individual expressions are unsequenced.
 [*Note 5*: In an expression that is evaluated more than once during the
 execution of a program, unsequenced and indeterminately sequenced
 evaluations of its subexpressions need not be performed consistently in
 different evaluations. — *end note*]
 The value computations of the operands of an operator are sequenced
+before the value computation of the result of the operator. The behavior
+is undefined if
+- a side effect on a memory location [[intro.memory]] or
+- starting or ending the lifetime of an object in a memory location
+is unsequenced relative to
+- another side effect on the same memory location,
+- starting or ending the lifetime of an object occupying storage that
+  overlaps with the memory location, or
+- a value computation using the value of any object in the same memory
+  location,
+and the two evaluations are not potentially concurrent
+[[intro.multithread]].
+[*Note 6*: Starting the lifetime of an object in a memory location can
+end the lifetime of objects in other memory locations
+[[basic.life]]. — *end note*]
+[*Note 7*: The next subclause imposes similar, but more complex
 restrictions on potentially concurrent computations. — *end note*]
 [*Example 3*:
 ``` cpp
   i = 7, i++, i++;              // i becomes 9
   i = i++ + 1;                  // the value of i is incremented
   i = i++ + i;                  // undefined behavior
   i = i + 1;                    // the value of i is incremented
+  union U { int x, y; } u;
+  (u.x = 1, 0) + (u.y = 2, 0);  // undefined behavior
 }
 ```
 — *end example*]
+When invoking a function *f* (whether or not the function is inline),
+every argument expression and the postfix expression designating *f* are
+sequenced before every precondition assertion of *f*
+[[dcl.contract.func]], which in turn are sequenced before every
+expression or statement in the body of *f*, which in turn are sequenced
+before every postcondition assertion of *f*.
+For each
+- function invocation,
+- evaluation of an *await-expression* [[expr.await]], or
+- evaluation of a *throw-expression* [[expr.throw]]
+*F*, each evaluation that does not occur within *F* but is evaluated on
+the same thread and as part of the same signal handler (if any) is
+either sequenced before all evaluations that occur within *F* or
+sequenced after all evaluations that occur within *F*;[^22]
 if *F* invokes or resumes a coroutine [[expr.await]], only evaluations
 subsequent to the previous suspension (if any) and prior to the next
 suspension (if any) are considered to occur within *F*.
 If a signal handler is executed as a result of a call to the
 `std::raise` function, then the execution of the handler is sequenced
 after the invocation of the `std::raise` function and before its return.
+[*Note 8*: When a signal is received for another reason, the execution
 of the signal handler is usually unsequenced with respect to the rest of
 the program. — *end note*]
+During the evaluation of an expression as a core constant expression
+[[expr.const]], evaluations of operands of individual operators and of
+subexpressions of individual expressions that are otherwise either
+unsequenced or indeterminately sequenced are evaluated in lexical order.

Diff to HTML by rtfpessoa