[stmt.stmt] - C++11 → C++14

Files changed (1) hide show

tmp/tmp2y_q0yuk/{from.md → to.md} +43 -38

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

@@ -117,16 +117,17 @@ if (x) {
 Thus after the `if` statement, `i` is no longer in scope.
 The rules for *condition*s apply both to *selection-statement*s and to
 the `for` and `while` statements ([[stmt.iter]]). The *declarator*
-shall not specify a function or an array. If the `auto` appears in the ,
-the type of the identifier being declared is deduced from the
-initializer as described in  [[dcl.spec.auto]].
 A name introduced by a declaration in a *condition* (either introduced
-by the *type-specifier-seq* or the *declarator* of the condition) is in
 scope from its point of declaration until the end of the substatements
 controlled by the condition. If the name is re-declared in the outermost
 block of a substatement controlled by the condition, the declaration
 that re-declares the name is ill-formed.
@@ -162,37 +163,37 @@ shall be either a *type-specifier* or `constexpr`.
 ### The `if` statement <a id="stmt.if">[[stmt.if]]</a>
 If the condition ([[stmt.select]]) yields `true` the first substatement
 is executed. If the `else` part of the selection statement is present
 and the condition yields `false`, the second substatement is executed.
-In the second form of `if` statement (the one including `else`), if the
-first substatement is also an `if` statement then that inner `if`
-statement shall contain an `else` part.[^1]
 ### The `switch` statement <a id="stmt.switch">[[stmt.switch]]</a>
 The `switch` statement causes control to be transferred to one of
 several statements depending on the value of a condition.
-The condition shall be of integral type, enumeration type, or of a class
-type for which a single non-explicit conversion function to integral or
-enumeration type exists ([[class.conv]]). If the condition is of class
-type, the condition is converted by calling that conversion function,
-and the result of the conversion is used in place of the original
-condition for the remainder of this section. Integral promotions are
-performed. Any statement within the `switch` statement can be labeled
-with one or more case labels as follows:
 ``` bnf
 'case' constant-expression ':'
 ```
 where the *constant-expression* shall be a converted constant
-expression ([[expr.const]]) of the promoted type of the switch
 condition. No two of the case constants in the same switch shall have
-the same value after conversion to the promoted type of the switch
-condition.
 There shall be at most one label of the form
 ``` cpp
 default :
@@ -344,25 +345,25 @@ The `for` statement
 ```
 is equivalent to
 except that names declared in the *for-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*.
 Thus the first statement specifies initialization for the loop; the
 condition ([[stmt.select]]) specifies a test, made before each
 iteration, such that the loop is exited when the condition becomes
 `false`; the expression often specifies incrementing that is done after
 each iteration.
 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 *for-init-statement* is a declaration, the scope of the name(s)
-declared extends to the end of the *for-statement*.
 ``` cpp
 int i = 42;
 int a[10];
@@ -421,23 +422,23 @@ exposition only, and `_RangeT` is the type of the *expression*, and
   are looked up in the scope of class `\mbox{_RangeT}` 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
- with argument-dependent lookup ([[basic.lookup.argdep]]). For the
- purposes of this name lookup, namespace `std` is an associated
-  namespace.
 ``` cpp
 int array[5] = { 1, 2, 3, 4, 5 };
 for (int& x : array)
   x *= 2;
 ```
 In the *decl-specifier-seq* of a *for-range-declaration*, each
-*decl-specifier* shall be either a *type-specifier* or `constexpr`.
 ## Jump statements <a id="stmt.jump">[[stmt.jump]]</a>
 Jump statements unconditionally transfer control.
@@ -510,17 +511,17 @@ equivalent to `goto` `contin`.
 A function returns to its caller by the `return` statement.
 A return statement with neither an *expression* nor a *braced-init-list*
 can be used only in functions that do not return a value, that is, a
-function with the return type `void`, a constructor ([[class.ctor]]),
-or a destructor ([[class.dtor]]). A return statement with an expression
-of non-void type can be used only in functions returning a value; the
-value of the expression is returned to the caller of the function. The
-value of the expression is implicitly converted to the return type of
-the function in which it appears. A return statement can involve the
-construction and copy or move of a temporary object (
 [[class.temporary]]). A copy or move operation associated with a return
 statement may be elided or considered as an rvalue for the purpose of
 overload resolution in selecting a constructor ([[class.copy]]). A
 return statement with a *braced-init-list* initializes the object or
 reference to be returned from the function by copy-list-initialization (
@@ -626,14 +627,17 @@ with static and thread storage duration are destroyed.
 There is an ambiguity in the grammar involving *expression-statement*s
 and *declaration*s: An *expression-statement* with a function-style
 explicit type conversion ([[expr.type.conv]]) as its leftmost
 subexpression can be indistinguishable from a *declaration* where the
 first *declarator* starts with a `(`. In those cases the *statement* is
-a *declaration*. To disambiguate, the whole *statement* might have to be
-examined to determine if it is an *expression-statement* or a
-*declaration*. This disambiguates many examples. assuming `T` is a
-*simple-type-specifier* ([[dcl.type]]),
 ``` cpp
 T(a)->m = 7;        // expression-statement
 T(a)++;             // expression-statement
 T(a,5)<<c;          // expression-statement
@@ -700,23 +704,24 @@ void f() {
 ```
 <!-- Link reference definitions -->
 [basic.lookup.argdep]: basic.md#basic.lookup.argdep
 [basic.lookup.classref]: basic.md#basic.lookup.classref
 [basic.scope]: basic.md#basic.scope
 [basic.scope.pdecl]: basic.md#basic.scope.pdecl
 [basic.start.init]: basic.md#basic.start.init
 [basic.start.term]: basic.md#basic.start.term
 [basic.stc.auto]: basic.md#basic.stc.auto
 [basic.stc.static]: basic.md#basic.stc.static
 [basic.stc.thread]: basic.md#basic.stc.thread
-[class.conv]: special.md#class.conv
 [class.copy]: special.md#class.copy
 [class.ctor]: special.md#class.ctor
 [class.dtor]: special.md#class.dtor
 [class.temporary]: special.md#class.temporary
 [conv]: conv.md#conv
 [dcl.init]: dcl.md#dcl.init
 [dcl.init.list]: dcl.md#dcl.init.list
 [dcl.meaning]: dcl.md#dcl.meaning
 [dcl.spec.auto]: dcl.md#dcl.spec.auto
 [dcl.type]: dcl.md#dcl.type

 Thus after the `if` statement, `i` is no longer in scope.
 The rules for *condition*s apply both to *selection-statement*s and to
 the `for` and `while` statements ([[stmt.iter]]). The *declarator*
+shall not specify a function or an array. The *decl-specifier-seq* shall
+not define a class or enumeration. If the `auto` appears in the , the
+type of the identifier being declared is deduced from the initializer as
+described in  [[dcl.spec.auto]].
 A name introduced by a declaration in a *condition* (either introduced
+by the *decl-specifier-seq* or the *declarator* of the condition) is in
 scope from its point of declaration until the end of the substatements
 controlled by the condition. If the name is re-declared in the outermost
 block of a substatement controlled by the condition, the declaration
 that re-declares the name is ill-formed.
 ### The `if` statement <a id="stmt.if">[[stmt.if]]</a>
 If the condition ([[stmt.select]]) yields `true` the first substatement
 is executed. If the `else` part of the selection statement is present
 and the condition yields `false`, the second substatement is executed.
+If the first substatement is reached via a label, the condition is not
+evaluated and the second substatement is not executed. In the second
+form of `if` statement (the one including `else`), if the first
+substatement is also an `if` statement then that inner `if` statement
+shall contain an `else` part.[^1]
 ### The `switch` statement <a id="stmt.switch">[[stmt.switch]]</a>
 The `switch` statement causes control to be transferred to one of
 several statements depending on the value of a condition.
+The condition shall be of integral type, enumeration type, or class
+type. If of class type, the condition is contextually implicitly
+converted (Clause  [[conv]]) to an integral or enumeration type. If the
+(possibly converted) type is subject to integral promotions (
+[[conv.prom]]), the condition is converted to the promoted type. Any
+statement within the `switch` statement can be labeled with one or more
+case labels as follows:
 ``` bnf
 'case' constant-expression ':'
 ```
 where the *constant-expression* shall be a converted constant
+expression ([[expr.const]]) of the adjusted type of the switch
 condition. No two of the case constants in the same switch shall have
+the same value after conversion.
 There shall be at most one label of the form
 ``` cpp
 default :
 ```
 is equivalent to
 except that names declared in the *for-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*.
 Thus the first statement specifies initialization for the loop; the
 condition ([[stmt.select]]) specifies a test, made before each
 iteration, such that the loop is exited when the condition becomes
 `false`; the expression often specifies incrementing that is done after
 each iteration.
 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 *for-init-statement* is a declaration, the scope of the name(s)
+declared extends to the end of the `for` statement.
 ``` cpp
 int i = 42;
 int a[10];
   are looked up in the scope of class `\mbox{_RangeT}` 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]]). Ordinary
+ unqualified lookup ([[basic.lookup.unqual]]) is not performed.
 ``` cpp
 int array[5] = { 1, 2, 3, 4, 5 };
 for (int& x : array)
   x *= 2;
 ```
 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.
 ## Jump statements <a id="stmt.jump">[[stmt.jump]]</a>
 Jump statements unconditionally transfer control.
 A function returns to its caller by the `return` statement.
 A return statement with neither an *expression* nor a *braced-init-list*
 can be used only in functions that do not return a value, that is, a
+function with the return type cv `void`, a constructor (
+[[class.ctor]]), or a destructor ([[class.dtor]]). A return statement
+with an expression of non-void type can be used only in functions
+returning a value; the value of the expression is returned to the caller
+of the function. The value of the expression is implicitly converted to
+the return type of the function in which it appears. A return statement
+can involve the construction and copy or move of a temporary object (
 [[class.temporary]]). A copy or move operation associated with a return
 statement may be elided or considered as an rvalue for the purpose of
 overload resolution in selecting a constructor ([[class.copy]]). A
 return statement with a *braced-init-list* initializes the object or
 reference to be returned from the function by copy-list-initialization (
 There is an ambiguity in the grammar involving *expression-statement*s
 and *declaration*s: An *expression-statement* with a function-style
 explicit type conversion ([[expr.type.conv]]) as its leftmost
 subexpression can be indistinguishable from a *declaration* where the
 first *declarator* starts with a `(`. In those cases the *statement* is
+a *declaration*.
+If the *statement* cannot syntactically be a *declaration*, there is no
+ambiguity, so this rule does not apply. The whole *statement* might need
+to be examined to determine whether this is the case. This resolves the
+meaning of many examples. Assuming `T` is a *simple-type-specifier* (
+[[dcl.type]]),
 ``` cpp
 T(a)->m = 7;        // expression-statement
 T(a)++;             // expression-statement
 T(a,5)<<c;          // expression-statement
 ```
 <!-- Link reference definitions -->
 [basic.lookup.argdep]: basic.md#basic.lookup.argdep
 [basic.lookup.classref]: basic.md#basic.lookup.classref
+[basic.lookup.unqual]: basic.md#basic.lookup.unqual
 [basic.scope]: basic.md#basic.scope
 [basic.scope.pdecl]: basic.md#basic.scope.pdecl
 [basic.start.init]: basic.md#basic.start.init
 [basic.start.term]: basic.md#basic.start.term
 [basic.stc.auto]: basic.md#basic.stc.auto
 [basic.stc.static]: basic.md#basic.stc.static
 [basic.stc.thread]: basic.md#basic.stc.thread
 [class.copy]: special.md#class.copy
 [class.ctor]: special.md#class.ctor
 [class.dtor]: special.md#class.dtor
 [class.temporary]: special.md#class.temporary
 [conv]: conv.md#conv
+[conv.prom]: conv.md#conv.prom
 [dcl.init]: dcl.md#dcl.init
 [dcl.init.list]: dcl.md#dcl.init.list
 [dcl.meaning]: dcl.md#dcl.meaning
 [dcl.spec.auto]: dcl.md#dcl.spec.auto
 [dcl.type]: dcl.md#dcl.type

Diff to HTML by rtfpessoa