[stmt.jump] - C++20 → C++23

Files changed (1) hide show

tmp/tmpcspwcxby/{from.md → to.md} +40 -51

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

@@ -1,7 +1,9 @@
 ## Jump statements <a id="stmt.jump">[[stmt.jump]]</a>
 Jump statements unconditionally transfer control.
 ``` bnf
 jump-statement:
     break ';'
@@ -9,43 +11,36 @@ jump-statement:
     return expr-or-braced-init-listₒₚₜ ';'
     coroutine-return-statement
     goto identifier ';'
 ```
-On exit from a scope (however accomplished), objects with automatic
-storage duration [[basic.stc.auto]] that have been constructed in that
-scope are destroyed in the reverse order of their construction.
-[*Note 1*: For temporaries, see  [[class.temporary]]. — *end note*]
-Transfer out of a loop, out of a block, or back past an initialized
-variable with automatic storage duration involves the destruction of
-objects with automatic storage duration that are in scope at the point
-transferred from but not at the point transferred to. (See  [[stmt.dcl]]
-for transfers into blocks).
-[*Note 2*: However, the program can be terminated (by calling
-`std::exit()` or `std::abort()` [[support.start.term]], for example)
-without destroying objects with automatic storage
-duration. — *end note*]
-[*Note 3*: A suspension of a coroutine [[expr.await]] is not considered
 to be an exit from a scope. — *end note*]
 ### The `break` statement <a id="stmt.break">[[stmt.break]]</a>
-The `break` statement shall occur only in an *iteration-statement* or a
-`switch` statement and causes termination of the smallest enclosing
-*iteration-statement* or `switch` statement; control passes to the
-statement following the terminated statement, if any.
 ### The `continue` statement <a id="stmt.cont">[[stmt.cont]]</a>
-The `continue` statement shall occur only in an *iteration-statement*
-and causes control to pass to the loop-continuation portion of the
-smallest enclosing *iteration-statement*, that is, to the end of the
-loop. More precisely, in each of the statements
 ``` cpp
 while (foo) {
   {
     // ...
@@ -81,39 +76,32 @@ A function returns to its caller by the `return` statement.
 The *expr-or-braced-init-list* of a `return` statement is called its
 operand. A `return` statement with no operand shall be used only in a
 function whose return type is cv `void`, a constructor [[class.ctor]],
 or a destructor [[class.dtor]]. A `return` statement with an operand of
-type `void` shall be used only in a function whose return type is
-cv `void`. A `return` statement with any other operand shall be used
-only in a function whose return type is not cv `void`; the `return`
-statement initializes the glvalue result or prvalue result object of the
-(explicit or implicit) function call by copy-initialization [[dcl.init]]
-from the operand.
-[*Note 1*: A `return` statement can involve an invocation of a
 constructor to perform a copy or move of the operand if it is not a
 prvalue or if its type differs from the return type of the function. A
-copy operation associated with a `return` statement may be elided or
 converted to a move operation if an automatic storage duration variable
 is returned [[class.copy.elision]]. — *end note*]
 [*Example 1*:
-``` cpp
-std::pair<std::string,int> f(const char* p, int x) {
-  return {p,x};
-}
-```
-— *end example*]
-The destructor for the returned object is potentially invoked (
-[[class.dtor]], [[except.ctor]]).
-[*Example 2*:
 ``` cpp
 class A {
   ~A() {}
 };
 A f() { return A(); }   // error: destructor of A is private (even though it is never invoked)
@@ -121,12 +109,12 @@ A f() { return A(); }   // error: destructor of A is private (even though it is
 — *end example*]
 Flowing off the end of a constructor, a destructor, or a non-coroutine
 function with a cv `void` return type is equivalent to a `return` with
-no operand. Otherwise, flowing off the end of a function other than
-`main` [[basic.start.main]] or a coroutine [[dcl.fct.def.coroutine]]
 results in undefined behavior.
 The copy-initialization of the result of the call is sequenced before
 the destruction of temporaries at the end of the full-expression
 established by the operand of the `return` statement, which, in turn, is
@@ -165,12 +153,13 @@ where *`final-suspend`* is the exposition-only label defined in
 - Otherwise, *S* is the *compound-statement* `{` *expression*ₒₚₜ  `;`
   *p*`.return_void()``; }`. The expression *p*`.return_void()` shall be
   a prvalue of type `void`.
 If *p*`.return_void()` is a valid expression, flowing off the end of a
-coroutine is equivalent to a `co_return` with no operand; otherwise
-flowing off the end of a coroutine results in undefined behavior.
 ### The `goto` statement <a id="stmt.goto">[[stmt.goto]]</a>
 The `goto` statement unconditionally transfers control to the statement
 labeled by the identifier. The identifier shall be a label

 ## Jump statements <a id="stmt.jump">[[stmt.jump]]</a>
+### General <a id="stmt.jump.general">[[stmt.jump.general]]</a>
 Jump statements unconditionally transfer control.
 ``` bnf
 jump-statement:
     break ';'
     return expr-or-braced-init-listₒₚₜ ';'
     coroutine-return-statement
     goto identifier ';'
 ```
+[*Note 1*: On exit from a scope (however accomplished), objects with
+automatic storage duration [[basic.stc.auto]] that have been constructed
+in that scope are destroyed in the reverse order of their construction.
+For temporaries, see  [[class.temporary]]. However, the program can be
+terminated (by calling `std::exit()` or `std::abort()`
+[[support.start.term]], for example) without destroying objects with
+automatic storage duration. — *end note*]
+[*Note 2*: A suspension of a coroutine [[expr.await]] is not considered
 to be an exit from a scope. — *end note*]
 ### The `break` statement <a id="stmt.break">[[stmt.break]]</a>
+A `break` statement shall be enclosed by [[stmt.pre]] an
+*iteration-statement* [[stmt.iter]] or a `switch` statement
+[[stmt.switch]]. The `break` statement causes termination of the
+smallest such enclosing statement; control passes to the statement
+following the terminated statement, if any.
 ### The `continue` statement <a id="stmt.cont">[[stmt.cont]]</a>
+A `continue` statement shall be enclosed by [[stmt.pre]] an
+*iteration-statement* [[stmt.iter]]. The `continue` statement causes
+control to pass to the loop-continuation portion of the smallest such
+enclosing statement, that is, to the end of the loop. More precisely, in
+each of the statements
 ``` cpp
 while (foo) {
   {
     // ...
 The *expr-or-braced-init-list* of a `return` statement is called its
 operand. A `return` statement with no operand shall be used only in a
 function whose return type is cv `void`, a constructor [[class.ctor]],
 or a destructor [[class.dtor]]. A `return` statement with an operand of
+type `void` shall be used only in a function that has a cv `void` return
+type. A `return` statement with any other operand shall be used only in
+a function that has a return type other than cv `void`; the `return`
+statement initializes the returned reference or prvalue result object of
+the (explicit or implicit) function call by copy-initialization
+[[dcl.init]] from the operand.
+[*Note 1*: A constructor or destructor does not have a return
+type. — *end note*]
+[*Note 2*: A `return` statement can involve an invocation of a
 constructor to perform a copy or move of the operand if it is not a
 prvalue or if its type differs from the return type of the function. A
+copy operation associated with a `return` statement can be elided or
 converted to a move operation if an automatic storage duration variable
 is returned [[class.copy.elision]]. — *end note*]
+The destructor for the result object is potentially invoked
+[[class.dtor]], [[except.ctor]].
 [*Example 1*:
 ``` cpp
 class A {
   ~A() {}
 };
 A f() { return A(); }   // error: destructor of A is private (even though it is never invoked)
 — *end example*]
 Flowing off the end of a constructor, a destructor, or a non-coroutine
 function with a cv `void` return type is equivalent to a `return` with
+no operand. Otherwise, flowing off the end of a function that is neither
+`main` [[basic.start.main]] nor a coroutine [[dcl.fct.def.coroutine]]
 results in undefined behavior.
 The copy-initialization of the result of the call is sequenced before
 the destruction of temporaries at the end of the full-expression
 established by the operand of the `return` statement, which, in turn, is
 - Otherwise, *S* is the *compound-statement* `{` *expression*ₒₚₜ  `;`
   *p*`.return_void()``; }`. The expression *p*`.return_void()` shall be
   a prvalue of type `void`.
 If *p*`.return_void()` is a valid expression, flowing off the end of a
+coroutine’s *function-body* is equivalent to a `co_return` with no
+operand; otherwise flowing off the end of a coroutine’s *function-body*
+results in undefined behavior.
 ### The `goto` statement <a id="stmt.goto">[[stmt.goto]]</a>
 The `goto` statement unconditionally transfers control to the statement
 labeled by the identifier. The identifier shall be a label

Diff to HTML by rtfpessoa