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

Files changed (1) hide show

tmp/tmpcb5rn27d/{from.md → to.md} +39 -55

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

@@ -1,7 +1,9 @@
 ## Iteration statements <a id="stmt.iter">[[stmt.iter]]</a>
 Iteration statements specify looping.
 ``` bnf
 iteration-statement:
     while '(' condition ')' statement
@@ -49,37 +51,17 @@ while (--x >= 0) {
 Thus after the `while` statement, `i` is no longer in scope.
 — *end example*]
-If a name introduced in an *init-statement* or *for-range-declaration*
-is redeclared in the outermost block of the substatement, the program is
-ill-formed.
-[*Example 2*:
-``` cpp
-void f() {
-  for (int i = 0; i < 10; ++i)
-    int i = 0;          // error: redeclaration
-  for (int i : { 1, 2, 3 })
-    int i = 1;          // error: redeclaration
-}
-```
-— *end example*]
 ### The `while` statement <a id="stmt.while">[[stmt.while]]</a>
 In the `while` statement the substatement is executed repeatedly until
-the value of the condition [[stmt.select]] becomes `false`. The test
-takes place before each execution of the substatement.
-When the condition of a `while` statement is a declaration, the scope of
-the variable that is declared extends from its point of declaration
-[[basic.scope.pdecl]] to the end of the `while` *statement*. A `while`
-statement is equivalent to
 ``` bnf
 label ':'
 '{'
    if '(' condition ')' '{'
@@ -145,42 +127,25 @@ is equivalent to
      expression ';'
    '}'
 '}'
 ```
-except that names declared in the *init-statement* are in the same
-declarative region as those declared in the *condition*, and except that
-a `continue` in *statement* (not enclosed in another iteration
-statement) will execute *expression* before re-evaluating *condition*.
 [*Note 1*: Thus the first statement specifies initialization for the
-loop; the condition [[stmt.select]] specifies a test, sequenced before
-each iteration, such that the loop is exited when the condition becomes
 `false`; the expression often specifies incrementing that is sequenced
 after each iteration. — *end note*]
 Either or both of the *condition* and the *expression* can be omitted. A
 missing *condition* makes the implied `while` clause equivalent to
 `while(true)`.
-If the *init-statement* is a declaration, the scope of the name(s)
-declared extends to the end of the `for` statement.
-[*Example 1*:
-``` cpp
-int i = 42;
-int a[10];
-for (int i = 0; i < 10; i++)
-  a[i] = i;
-int j = i;          // j = 42
-```
-— *end example*]
 ### The range-based `for` statement <a id="stmt.ranged">[[stmt.ranged]]</a>
 The range-based `for` statement
 ``` bnf
@@ -207,25 +172,24 @@ where
 - if the *for-range-initializer* is an *expression*, it is regarded as
   if it were surrounded by parentheses (so that a comma operator cannot
   be reinterpreted as delimiting two *init-declarator*s);
 - *`range`*, *`begin`*, and *`end`* are variables defined for exposition
   only; and
-- *begin-expr* and *end-expr* are determined as follows:
   - if the *for-range-initializer* is an expression of array type `R`,
-    *begin-expr* and *end-expr* are *`range`* and *`range`* `+` `N`,
     respectively, where `N` is the array bound. If `R` is an array of
     unknown bound or an array of incomplete type, the program is
     ill-formed;
   - if the *for-range-initializer* is an expression of class type `C`,
- the *unqualified-id*s `begin` and `end` are looked up in the scope
- of `C` as if by class member access lookup
- [[basic.lookup.classref]], and if both find at least one
-    declaration, *begin-expr* and *end-expr* are `range.begin()` and
     `range.end()`, respectively;
-  - otherwise, *begin-expr* and *end-expr* are `begin(range)` and
-    `end(range)`, respectively, where `begin` and `end` are looked up in
- the associated namespaces [[basic.lookup.argdep]].
     \[*Note 1*: Ordinary unqualified lookup [[basic.lookup.unqual]] is
     not performed. — *end note*]
 [*Example 1*:
@@ -235,9 +199,29 @@ for (int& x : array)
   x *= 2;
 ```
 — *end example*]
 In the *decl-specifier-seq* of a *for-range-declaration*, each
 *decl-specifier* shall be either a *type-specifier* or `constexpr`. The
 *decl-specifier-seq* shall not define a class or enumeration.

 ## Iteration statements <a id="stmt.iter">[[stmt.iter]]</a>
+### General <a id="stmt.iter.general">[[stmt.iter.general]]</a>
 Iteration statements specify looping.
 ``` bnf
 iteration-statement:
     while '(' condition ')' statement
 Thus after the `while` statement, `i` is no longer in scope.
 — *end example*]
 ### The `while` statement <a id="stmt.while">[[stmt.while]]</a>
 In the `while` statement the substatement is executed repeatedly until
+the value of the condition [[stmt.pre]] becomes `false`. The test takes
+place before each execution of the substatement.
+A `while` statement is equivalent to
 ``` bnf
 label ':'
 '{'
    if '(' condition ')' '{'
      expression ';'
    '}'
 '}'
 ```
+except that the *init-statement* is in the same scope as the
+*condition*, and except that a `continue` in *statement* (not enclosed
+in another iteration statement) will execute *expression* before
+re-evaluating *condition*.
 [*Note 1*: Thus the first statement specifies initialization for the
+loop; the condition [[stmt.pre]] specifies a test, sequenced before each
+iteration, such that the loop is exited when the condition becomes
 `false`; the expression often specifies incrementing that is sequenced
 after each iteration. — *end note*]
 Either or both of the *condition* and the *expression* can be omitted. A
 missing *condition* makes the implied `while` clause equivalent to
 `while(true)`.
 ### The range-based `for` statement <a id="stmt.ranged">[[stmt.ranged]]</a>
 The range-based `for` statement
 ``` bnf
 - if the *for-range-initializer* is an *expression*, it is regarded as
   if it were surrounded by parentheses (so that a comma operator cannot
   be reinterpreted as delimiting two *init-declarator*s);
 - *`range`*, *`begin`*, and *`end`* are variables defined for exposition
   only; and
+- *`begin-expr`* and *`end-expr`* are determined as follows:
   - if the *for-range-initializer* is an expression of array type `R`,
+    *`begin-expr`* and *`end-expr`* are *`range`* and *`range`* `+` `N`,
     respectively, where `N` is the array bound. If `R` is an array of
     unknown bound or an array of incomplete type, the program is
     ill-formed;
   - if the *for-range-initializer* is an expression of class type `C`,
+ and searches in the scope of `C` [[class.member.lookup]] for the
+ names `begin` and `end` each find at least one declaration,
+ *`begin-expr`* and *`end-expr`* are `range.begin()` and
     `range.end()`, respectively;
+  - otherwise, *`begin-expr`* and *`end-expr`* are `begin(range)` and
+    `end(range)`, respectively, where `begin` and `end` undergo
+ argument-dependent lookup [[basic.lookup.argdep]].
     \[*Note 1*: Ordinary unqualified lookup [[basic.lookup.unqual]] is
     not performed. — *end note*]
 [*Example 1*:
   x *= 2;
 ```
 — *end example*]
+[*Note 2*: The lifetime of some temporaries in the
+*for-range-initializer* is extended to cover the entire loop
+[[class.temporary]]. — *end note*]
+[*Example 2*:
+``` cpp
+using T = std::list<int>;
+const T& f1(const T& t) { return t; }
+const T& f2(T t)        { return t; }
+T g();
+void foo() {
+  for (auto e : f1(g())) {}     // OK, lifetime of return value of g() extended
+  for (auto e : f2(g())) {}     // undefined behavior
+}
+```
+— *end example*]
 In the *decl-specifier-seq* of a *for-range-declaration*, each
 *decl-specifier* shall be either a *type-specifier* or `constexpr`. The
 *decl-specifier-seq* shall not define a class or enumeration.

Diff to HTML by rtfpessoa