______________________________________________________________________
6 Statements [stmt.stmt]
______________________________________________________________________
1 Except as indicated, statements are executed in sequence.
statement:
labeled-statement
expression-statement
compound-statement
selection-statement
iteration-statement
jump-statement
declaration-statement
try-block
6.1 Labeled statement [stmt.label]
1 A statement can be labeled.
labeled-statement:
identifier : statement
case constant-expression : statement
default : statement
An identifier label declares the identifier. The only use of an iden
tifier label is as the target of a goto. The scope of a label is the
function in which it appears. Labels cannot be redeclared within a
function. A label can be used in a goto statement before its defini
tion. Labels have their own name space and do not interfere with
other identifiers.
2 Case labels and default labels can occur only in switch statements.
6.2 Expression statement [stmt.expr]
1 Most statements are expression statements, which have the form
expression-statement:
expressionopt ;
Usually expression statements are assignments or function calls. All
side effects from an expression statement are completed before the
next statement is executed. An expression statement with the expres
sion missing is called a null statement; it is useful to carry a label
just before the } of a compound statement and to supply a null body to
an iteration statement such as while (_stmt.while_).
6.3 Compound statement or block [stmt.block]
1 So that several statements can be used where one is expected, the com
pound statement (also, and equivalently, called block) is provided.
compound-statement:
{ statement-seqopt }
statement-seq:
statement
statement-seq statement
A compound statement defines a local scope (_basic.scope_).
2 Note that a declaration is a statement (_stmt.dcl_).
6.4 Selection statements [stmt.select]
1 Selection statements choose one of several flows of control.
selection-statement:
if ( condition ) statement
if ( condition ) statement else statement
switch ( condition ) statement
condition:
expression
type-specifier-seq declarator = assignment-expression
The statement in a selection-statement (both statements, in the else
form of the if statement) implicitly defines a local scope
(_basic.scope_). That is, if the statement in a selection-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 state
ment. For example,
if (x)
int i;
may be equivalently rewritten as
if (x) {
int i;
}
Thus after the if statement, i is no longer in scope.
2 The rules for conditions apply both to selection-statements and to the
for and while statements (_stmt.iter_). The declarator may not spec
ify a function or an array. The type-specifier shall not contain
typedef and shall not declare a new class or enumeration.
3 A name introduced by a declaration in a condition is in scope from its
point of declaration until the end of the statements controlled by the
condition. The value of a condition that is an initialized declara
tion is the value of the initialized variable; the value of a condi
tion that is an expression is the value of the expression. The value
of the condition will be referred to as simply the condition where the
usage is unambiguous.
4 A variable, constant, etc. in the outermost block of a statement con
trolled by a condition may not have the same name as a variable, con
stant, etc. declared in the condition.
5 If a condition can be syntactically resolved as either an expression
or the declaration of a local name, it is interpreted as a declara
tion.
6.4.1 The if statement [stmt.if]
1 The condition is converted to type bool; if that is not possible, the
program is ill-formed. If it yields true the first substatement is
executed. If else is used and the condition yields false, the second
substatement is executed. The else ambiguity is resolved by connect
ing an else with the last encountered else-less if.
6.4.2 The switch statement [stmt.switch]
1 The switch statement causes control to be transferred to one of sev
eral statements depending on the value of a condition.
2 The condition must be of integral type or of a class type for which an
unambiguous conversion to integral type exists (_class.conv_). Inte
gral promotion is performed. Any statement within the statement may
be labeled with one or more case labels as follows:
case constant-expression :
where the constant-expression (_expr.const_) is converted to the pro
moted type of the switch condition. No two of the case constants in
the same switch may have the same value.
3 There may be at most one label of the form
default :
within a switch statement.
4 Switch statements may be nested; a case or default label is associated
with the smallest switch enclosing it.
5 When the switch statement is executed, its condition is evaluated and
compared with each case constant. If one of the case constants is
equal to the value of the condition, control is passed to the state
ment following the matched case label. If no case constant matches
the condition, and if there is a default label, control passes to the
statement labeled by the default label. If no case matches and if
there is no default then none of the statements in the switch is exe
cuted.
6 case and default labels in themselves do not alter the flow of con
trol, which continues unimpeded across such labels. To exit from a
switch, see break, _stmt.break_.
7 Usually, the statement that is the subject of a switch is compound.
Declarations may appear in the statement of a switch-statement.
6.5 Iteration statements [stmt.iter]
1 Iteration statements specify looping.
iteration-statement:
while ( condition ) statement
do statement while ( expression ) ;
for ( for-init-statement conditionopt ; expressionopt ) statement
for-init-statement:
expression-statement
declaration-statement
2 Note that a for-init-statement ends with a semicolon.
3 The statement in an iteration-statement implicitly defines a local
scope (_basic.scope_) which is entered and exited each time through
the loop. That is, if the statement 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 state
ment. For example,
while (--x >= 0)
int i;
may be equivalently rewritten as
while (--x >= 0) {
int i;
}
Thus after the while statement, i is no longer in scope.
4 See _stmt.select_ for the rules on conditions.
6.5.1 The while statement [stmt.while]
1 In the while statement the substatement is executed repeatedly until
the value of the condition becomes false. The test takes place before
each execution of the statement.
2 The condition is converted to bool (_conv.bool_).
6.5.2 The do statement [stmt.do]
1 In the do statement the substatement is executed repeatedly until the
value of the condition becomes false. The test takes place after each
execution of the statement.
2 The condition is converted to bool (_conv.bool_).
6.5.3 The for statement [stmt.for]
1 The for statement
for ( for-init-statement conditionopt ; expressionopt ) statement
is equivalent to
for-init-statement
while ( condition ) {
statement
expression ;
}
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 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. The condi
tion is converted to bool (_conv.bool_).
2 Either or both of the condition and the expression may be dropped. A
missing condition makes the implied while clause equivalent to
while(true).
3 If the for-init-statement is a declaration, the scope of the name(s)
declared extends to the end of the for-statement. For example:
int i = 42;
int a[10];
for (int i = 0; i < 10; i++)
a[i] = i;
int j = i; // j = 42
6.6 Jump statements [stmt.jump]
1 Jump statements unconditionally transfer control.
jump-statement:
break ;
continue ;
return expressionopt ;
goto identifier ;
2 On exit from a scope (however accomplished), destructors
(_class.dtor_) are called for all constructed objects with automatic
storage duration (_basic.stc.auto_) (named objects or temporaries)
that are declared in that scope, in the reverse order of their decla
ration. Transfer out of a loop, out of a block, or back past an ini
tialized variable with automatic storage duration involves the
destruction of variables 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). However, the program
may be terminated (by calling exit() or abort(), for example) without
destroying class objects with automatic storage duration.
6.6.1 The break statement [stmt.break]
1 The break statement may 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 state
ment following the terminated statement, if any.
6.6.2 The continue statement [stmt.cont]
1 The continue statement may occur only in an iteration-statement and
causes control to pass to the loop-continuation portion of the small
est enclosing iteration-statement, that is, to the end of the loop.
More precisely, in each of the statements
while (foo) { do { for (;;) {
// ... // ... // ...
contin: ; contin: ; contin: ;
} } while (foo); }
a continue not contained in an enclosed iteration statement is equiva
lent to goto contin.
6.6.3 The return statement [stmt.return]
1 A function returns to its caller by the return statement.
2 A return statement without an expression can be used only in functions
that do not return a value, that is, a function with the return value
type void, a constructor (_class.ctor_), or a destructor
(_class.dtor_). A return statement with an expression can be used
only in functions returning a value; the value of the expression is
returned to the caller of the function. If required, the expression
is converted, as in an initialization (_dcl.init_), to the return type
of the function in which it appears. A return statement may involve
the construction and copy of a temporary object (_class.temporary_).
Flowing off the end of a function is equivalent to a return with no
value; this results in undefined behavior in a value-returning func
tion.
6.6.4 The goto statement [stmt.goto]
1 The goto statement unconditionally transfers control to the statement
labeled by the identifier. The identifier must be a label
(_stmt.label_) located in the current function.
6.7 Declaration statement [stmt.dcl]
1 A declaration statement introduces one or more new identifiers into a
block; it has the form
declaration-statement:
declaration
If an identifier introduced by a declaration was previously declared
in an outer block, the outer declaration is hidden for the remainder
of the block, after which it resumes its force.
2 Variables with automatic storage duration (_basic.stc.auto_) are ini
tialized each time their declaration-statement is executed. Variables
with automatic storage duration declared in the block are destroyed on
exit from the block (_stmt.jump_).
3 It is possible to transfer into a block, but not in a way that
bypasses declarations with initialization. A program that jumps from
a point where a local variable with automatic storage duration is not
in scope to a point where it is in scope is ill-formed unless the
variable has pointer or arithmetic type or is an aggregate
(_dcl.init.aggr_), and is declared without an initializer
(_dcl.init_). For example,
void f()
{
// ...
goto lx; // ill-formed: jump into scope of `a'
// ...
ly:
X a = 1;
// ...
lx:
goto ly; // ok, jump implies destructor
// call for `a' followed by construction
// again immediately following label ly
}
4 The default initialization to zero (_dcl.init_) of all local objects
with static storage duration (_basic.stc.static_) is performed before
any other initialization takes place. A local object with static
storage duration (_basic.stc.static_) initialized with a constant-
expression is initialized before its block is first entered. A local
object with static storage duration not initialized with a constant-
expression is initialized the first time control passes completely
through its declaration. If the initialization exits by throwing an
exception, the initialization is not complete, so it will be tried
again the next time the function is called.
5 The destructor for a local object with static storage duration will be
executed if and only if the variable was constructed. The destructor
must be called either immediately before or as part of the calls of
the atexit() functions (_basic.start.term_). Exactly when is unspeci
fied.
6.8 Ambiguity resolution [stmt.ambig]
1 There is an ambiguity in the grammar involving expression-statements
and declarations: An expression-statement with a function-style
explicit type conversion (_expr.type.conv_) as its leftmost subexpres
sion can be indistinguishable from a declaration where the first
declarator starts with a (. In those cases the statement is a decla
ration.
2 To disambiguate, the whole statement may have to be examined to deter
mine if it is an expression-statement or a declaration. This disam
biguates many examples. For example, assuming T is a simple-type-
specifier (_dcl.type_),
T(a)->m = 7; // expression-statement
T(a)++; // expression-statement
T(a,5)<<c; // expression-statement
T(*d)(int); // declaration
T(e)[]; // declaration
T(f) = { 1, 2 }; // declaration
T(*g)(double(3)); // declaration
In the last example above, g, which is a pointer to T, is initialized
to double(3). This is of course ill-formed for semantic reasons, but
that does not affect the syntactic analysis.
3 The remaining cases are declarations. For example,
T(a); // declaration
T(*b)(); // declaration
T(c)=7; // declaration
T(d),e,f=3; // declaration
T(g)(h,2); // declaration
4 The disambiguation is purely syntactic; that is, the meaning of the
names, beyond whether they are type-ids or not, is not used in the
disambiguation.
5 A slightly different ambiguity between expression-statements and dec
larations is resolved by requiring a type-id for function declarations
within a block (_stmt.block_). For example,
void g()
{
int f(); // declaration
int a; // declaration
f(); // expression-statement
a; // expression-statement
}