8 Statements [stmt.stmt]

8.7 Jump statements [stmt.jump]

1
#
Jump statements unconditionally transfer control.
jump-statement:
	break ;
	continue ;
	return expr-or-braced-init-list ;
	coroutine-return-statement
	goto identifier ;
2
#
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.
[ Note
:
For temporaries, see [class.temporary].
— end note
 ]
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.
(See [stmt.dcl] for transfers into blocks).
[ Note
:
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
:
A suspension of a coroutine ([expr.await]) is not considered to be an exit from a scope.
— end note
 ]

8.7.1 The break statement [stmt.break]

1
#
The break statement shall 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 statement following the terminated statement, if any.

8.7.2 The continue statement [stmt.cont]

1
#
The continue statement shall occur only in an iteration-statement and causes control to pass to the loop-continuation portion of the smallest enclosing iteration-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.3 The return statement [stmt.return]

1
#
A function returns to its caller by the return statement.
2
#
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, or a destructor.
A return statement with an operand of type void shall be used only in a function whose return type is cv void.
A return statement with any other operand shall be used only in a function whose return type is not cv void; the return statement initializes the glvalue result or prvalue result object of the (explicit or implicit) function call by copy-initialization from the operand.
[ Note
:
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 may be elided or converted to a move operation if an automatic storage duration variable is returned ([class.copy.elision]).
— end note
 ]
[ Example
: 
std::pair<std::string,int> f(const char* p, int x) {
  return {p,x};
}
— end example
 ]
The destructor for the returned object is potentially invoked ([class.dtor], [except.ctor]).
[ Example
: 
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 other than main or a coroutine ([dcl.fct.def.coroutine]) results in undefined behavior.
3
#
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.4 The co_­return statement [stmt.return.coroutine]

coroutine-return-statement:
	co_return expr-or-braced-init-list ;
1
#
A coroutine returns to its caller or resumer ([dcl.fct.def.coroutine]) by the co_­return statement or when suspended ([expr.await]).
A coroutine shall not enclose a return statement ([stmt.return]).
[ Note
:
For this determination, it is irrelevant whether the return statement is enclosed by a discarded statement ([stmt.if]).
— end note
 ]
2
#
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:
3
#
If p.return_­void() is a valid expression, flowing off the end of a coroutine is equivalent to a co_­return with no operand; otherwise flowing off the end of a coroutine results in undefined behavior.

8.7.5 The goto statement [stmt.goto]

1
#
The goto statement unconditionally transfers control to the statement labeled by the identifier.
The identifier shall be a label located in the current function.