8 Statements [stmt.stmt]

8.7 Jump statements [stmt.jump]

8.7.1 General [stmt.jump.general]

Jump statements unconditionally transfer control.

jump-statement:
break ;
continue ;
return expr-or-braced-init-list

_{o p t}

;
coroutine-return-statement
goto identifier ;

[Note 1:

On exit from a scope (however accomplished), objects with automatic storage duration that have been constructed in that scope are destroyed in the reverse order of their construction.

For temporaries, see [class.temporary].

However, the program can be terminated (by calling std::exit() or std::abort() ([support.start.term]), for example) without destroying objects with automatic storage duration.

— end note]

[Note 2:

A suspension of a coroutine ([expr.await]) is not considered to be an exit from a scope.

— end note]

8.7.2 The break statement [stmt.break]

A break statement shall be enclosed by ([stmt.pre]) an iteration-statement ([stmt.iter]) or a switch statement ([stmt.switch]).

The break statement causes termination of the smallest such enclosing statement; control passes to the statement following the terminated statement, if any.

8.7.3 The continue statement [stmt.cont]

A continue statement shall be enclosed by ([stmt.pre]) an iteration-statement ([stmt.iter]).

The continue statement causes control to pass to the loop-continuation portion of the smallest such enclosing statement, that is, to the end of the loop.

More precisely, in each of the statements

while (foo) { { // ... } contin: ; }

do { { // ... } contin: ; } while (foo);

for (;;) { { // ... } contin: ; }

a continue not contained in an enclosed iteration statement is equivalent to goto contin.

8.7.4 The return statement [stmt.return]

A function returns control to its caller by the return statement.

The expr-or-braced-init-list of a return statement is called its operand.

A return statement with no operand shall be used only in a function whose return type is cv void, a constructor ([class.ctor]), or a destructor ([class.dtor]).

A return statement with an operand of type void shall be used only in a function that has a cv void return type.

A return statement with any other operand shall be used only in a function that has a return type other than cv void; the return statement initializes the returned reference or prvalue result object of the (explicit or implicit) function call by copy-initialization from the operand.

[Note 1:

A constructor or destructor does not have a return type.

— end note]

[Note 2:

A return statement can involve an invocation of a constructor to perform a copy or move of the operand if it is not a prvalue or if its type differs from the return type of the function.

A copy operation associated with a return statement can be elided or converted to a move operation if an automatic storage duration variable is returned ([class.copy.elision]).

— end note]

The destructor for the result object is potentially invoked ([class.dtor], [except.ctor]).

[Example 1: class A { ~A() {} }; A f() { return A(); } // error: destructor of A is private (even though it is never invoked) — end example]

Flowing off the end of a constructor, a destructor, or a non-coroutine function with a cv void return type is equivalent to a return with no operand.

Otherwise, flowing off the end of a function that is neither main ([basic.start.main]) nor a coroutine ([dcl.fct.def.coroutine]) results in undefined behavior.

The copy-initialization of the result of the call is sequenced before the destruction of temporaries at the end of the full-expression established by the operand of the return statement, which, in turn, is sequenced before the destruction of local variables ([stmt.jump]) of the block enclosing the return statement.

8.7.5 The co_return statement [stmt.return.coroutine]

coroutine-return-statement:
co_return expr-or-braced-init-list

_{o p t}

;

A co_return statement transfers control to the caller or resumer of a coroutine ([dcl.fct.def.coroutine]).

A coroutine shall not enclose a return statement ([stmt.return]).

[Note 1:

For this determination, it is irrelevant whether the return statement is enclosed by a discarded statement ([stmt.if]).

— end note]

The expr-or-braced-init-list of a co_return statement is called its operand.

Let p be an lvalue naming the coroutine promise object ([dcl.fct.def.coroutine]).

A co_return statement is equivalent to:

{ S; goto final-suspend; }

where final-suspend is the exposition-only label defined in [dcl.fct.def.coroutine] and S is defined as follows:

(2.1)
If the operand is a braced-init-list or an expression of non-void type, S is p.return_value(expr-or-braced-init-list).

The expression S shall be a prvalue of type void.
(2.2)
Otherwise, S is the compound-statement { expression $_{o p t}$ ; p.return_void(); }.

The expression p.return_void() shall be a prvalue of type void.

If a search for the name return_void in the scope of the promise type finds any declarations, flowing off the end of a coroutine's function-body is equivalent to a co_return with no operand; otherwise flowing off the end of a coroutine's function-body results in undefined behavior.

8.7.6 The goto statement [stmt.goto]

The goto statement unconditionally transfers control to the statement labeled by the identifier.

The identifier shall be a label located in the current function.