Statements

Statements are fragments of the C++ program that are executed in sequence. The body of any function is a sequence of statements. For example:

int main()
{
    int n = 1;                        // declaration statement
    n = n + 1;                        // expression statement
    std::cout << "n = " << n << '\n'; // expression statement
    return 0;                         // return statement
}

C++ includes the following types of statements:

• Labeled statements
• Expression statements
• Compound statements
• Selection statements
• Iteration statements

• Jump statements

• Declaration statements
• try blocks

Labeled statements

A labeled statement labels a statement for control flow purposes.

Labels

label is defined as

Two identifier labels in a function must not have the same identifier . identifier s in labels are not found by unqualified lookup: a label can have the same name as any other entity in the program.

case labels and default labels must be enclosed by switch statements.

void f()
{
    label1: 1 + 1; // a labeled statement
    label1: 1 - 1; // Error: cannot repeat label identifiers in the same function
    label2:        // label can appear at the end of a block standalone since C++23
}

Control-flow-limited statements

The following statements are control-flow-limited statements :

• The compound-statement of a try block.
• The compound-statement of a handler.

For each control-flow-limited statement S:

• All goto target labels delcared in S can only be referred to by statements in S.
• Each case or default label appearing within S can only be associated with a switch statement within S.

Expression statements

An expression statement is an expression followed by a semicolon.

Most statements in a typical C++ program are expression statements, such as assignments or function calls.

An expression statement without an expression is called a null statement. It is often used to provide an empty body to a for or while loop. It can also be used to carry a label in the end of a compound statement.(until C++23)

Compound statements

A compound statement or block groups a sequence of statements into a single statement.

When one statement is expected, but multiple statements need to be executed in sequence (for example, in an if statement or a loop), a compound statement may be used:

if (x > 5)          // start of if statement
{                   // start of block
    int n = 1;      // declaration statement
    std::cout << n; // expression statement
}                   // end of block, end of if statement

Each compound statement introduces its own block scope; variables declared inside a block are destroyed at the closing brace in reverse order:

int main()
{ // start of outer block
    {                                // start of inner block
        std::ofstream f("test.txt"); // declaration statement
        f << "abc\n";                // expression statement
    }                                // end of inner block, f is flushed and closed
    std::ifstream f("test.txt"); // declaration statement
    std::string str;             // declaration statement
    f >> str;                    // expression statement
} // end of outer block, str is destroyed, f is closed

Selection statements

A selection statement chooses between one of several control flows.

Iteration statements

An iteration statement repeatedly executes some code.

Jump statements

A jump statement unconditionally transfers control flow.

Note: for all jump statements, 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. If multiple objects were initialized, the order of destruction is the opposite of the order of initialization.

Declaration statements

A declaration statement introduces one or more identifiers into a block.

try blocks

A try block catches exceptions thrown when executing other statements.

Substatements

A substatement of a statement is one of the following:

• For a labeled statement, its statement .
• For a compound statement, any statement of its statement... .
• For a selection statement, any of its statement  or compound-statement (since C++23).
• For an iteration statement, its statement .

A statement S1 encloses a statement S2 if any of the following conditions is satisfied:

• S2 is a substatement of S1
• S1 is a selection statement, expansion statement(since C++26) or iteration statement, and S2 is the init-statement of S1.
• S1 is a try block, and S2 is either its compound-statement or the compound-statement of any handler in its handler-seq .
• S1 encloses a statement S3 and S3 encloses S2.

A statement S1 is enclosed by a statement S2 if S2 encloses S1.

See also