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

Files changed (1) hide show

tmp/tmpn27zll86/{from.md → to.md} +68 -50

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

@@ -2,14 +2,14 @@
 Iteration statements specify looping.
 ``` bnf
 iteration-statement:
- 'while (' condition ')' statement
- 'do' statement 'while (' expression ') ;'
- 'for (' init-statement conditionₒₚₜ ';' expressionₒₚₜ ')' statement
- 'for (' for-range-declaration ':' for-range-initializer ')' statement
 ```
 ``` bnf
 for-range-declaration:
     attribute-specifier-seqₒₚₜ decl-specifier-seq declarator
@@ -25,16 +25,14 @@ See  [[dcl.meaning]] for the optional *attribute-specifier-seq* in a
 *for-range-declaration*.
 [*Note 1*: An *init-statement* ends with a semicolon. — *end note*]
 The substatement in an *iteration-statement* implicitly defines a block
-scope ([[basic.scope]]) which is entered and exited each time through
-the loop.
-If the substatement in an iteration-statement is a single statement and
-not a *compound-statement*, it is as if it was rewritten to be a
-compound-statement containing the original statement.
 [*Example 1*:
 ``` cpp
 while (--x >= 0)
@@ -71,36 +69,31 @@ void f() {
 — *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 of the form
-``` cpp
-while (T t = x) statement
-```
-is equivalent to
-``` cpp
-label:
-{                   // start of condition scope
-  T t = x;
-  if (t) {
       statement
- goto label;
- }
-}                   // end of condition scope
 ```
-The variable created in a condition is destroyed and created with each
 iteration of the loop.
 [*Example 1*:
 ``` cpp
@@ -121,39 +114,51 @@ In the while-loop, the constructor and destructor are each called twice,
 once for the condition that succeeds and once for the condition that
 fails.
 — *end example*]
 ### The `do` statement <a id="stmt.do">[[stmt.do]]</a>
-The expression is contextually converted to `bool` (Clause  [[conv]]);
-if that conversion is ill-formed, the program is ill-formed.
 In the `do` statement the substatement is executed repeatedly until the
 value of the expression becomes `false`. The test takes place after each
 execution of the statement.
 ### The `for` statement <a id="stmt.for">[[stmt.for]]</a>
 The `for` statement
 ``` bnf
-'for (' init-statement conditionₒₚₜ ';' expressionₒₚₜ ')' statement
 ```
 is equivalent to
 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)`.
@@ -177,39 +182,52 @@ int j = i;          // j = 42
 ### The range-based `for` statement <a id="stmt.ranged">[[stmt.ranged]]</a>
 The range-based `for` statement
 ``` bnf
-'for (' for-range-declaration ':' for-range-initializer ')' statement
 ```
 is equivalent to
 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 + __bound`,
-    respectively, where `__bound` 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 either (or both) finds 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*:
 ``` cpp
 int array[5] = { 1, 2, 3, 4, 5 };

 Iteration statements specify looping.
 ``` bnf
 iteration-statement:
+    while '(' condition ')' statement
+    do statement while '(' expression ')' ';'
+    for '(' init-statement conditionₒₚₜ ';' expressionₒₚₜ ')' statement
+    for '(' init-statementₒₚₜ for-range-declaration ':' for-range-initializer ')' statement
 ```
 ``` bnf
 for-range-declaration:
     attribute-specifier-seqₒₚₜ decl-specifier-seq declarator
 *for-range-declaration*.
 [*Note 1*: An *init-statement* ends with a semicolon. — *end note*]
 The substatement in an *iteration-statement* implicitly defines a block
+scope [[basic.scope]] which is entered and exited each time through the
+loop. If the substatement in an *iteration-statement* is a single
+statement and not a *compound-statement*, it is as if it was rewritten
+to be a *compound-statement* containing the original statement.
 [*Example 1*:
 ``` cpp
 while (--x >= 0)
 — *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 ')' '{'
       statement
+ goto label ';'
+   '}'
+'}'
 ```
+[*Note 1*:
+The variable created in the condition is destroyed and created with each
 iteration of the loop.
 [*Example 1*:
 ``` cpp
 once for the condition that succeeds and once for the condition that
 fails.
 — *end example*]
+— *end note*]
 ### The `do` statement <a id="stmt.do">[[stmt.do]]</a>
+The expression is contextually converted to `bool` [[conv]]; if that
+conversion is ill-formed, the program is ill-formed.
 In the `do` statement the substatement is executed repeatedly until the
 value of the expression becomes `false`. The test takes place after each
 execution of the statement.
 ### The `for` statement <a id="stmt.for">[[stmt.for]]</a>
 The `for` statement
 ``` bnf
+for '(' init-statement conditionₒₚₜ ';' expressionₒₚₜ ')' statement
 ```
 is equivalent to
+``` bnf
+'{'
+   init-statement
+   while '(' condition ')' '{'
+     statement
+     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)`.
 ### The range-based `for` statement <a id="stmt.ranged">[[stmt.ranged]]</a>
 The range-based `for` statement
 ``` bnf
+for '(' init-statementₒₚₜ for-range-declaration ':' for-range-initializer ')' statement
 ```
 is equivalent to
+``` bnf
+'{'
+   init-statementₒₚₜ
+   auto '&&'range '=' for-range-initializer ';'
+   auto begin '=' begin-expr ';'
+   auto end '=' end-expr ';'
+   for '(' ';' begin '!=' end';' '++'begin ')' '{'
+     for-range-declaration '=' '*' begin ';'
+     statement
+   '}'
+'}'
+```
 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*:
 ``` cpp
 int array[5] = { 1, 2, 3, 4, 5 };

Diff to HTML by rtfpessoa