Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://en.cppreference.com/w/cpp/language/../named_req/../language/return.html below:

return statement - cppreference.com

Terminates the current function and returns the specified value (if any) to the caller.

Evaluates the

, terminates the current function and returns the result of the

to the caller, after

to the function return type. The

is optional in functions whose return type is (possibly cv-qualified)

, and disallowed in constructors and in destructors.

In a coroutine, the keyword

must be used instead of

for the final suspension point (see

for details).

The expression or braced-init-list(since C++11) (if any) is known as the operand of the return statement.

There is a sequence point between the copy-initialization of the result of the function call and the destruction of all temporaries at the end of expression.

The copy-initialization of the result of the function call is sequenced-before the destruction of all temporaries at the end of expression, which, in turn, is sequenced-before the destruction of local variables of the block enclosing the return statement.

If the return type of the function is a reference type and a return statement (1,2) binds the returned reference to the result of a temporary expression, the program is ill-formed.

If control reaches the end of

• a function with the return type (possibly cv-qualified) void,
• a constructor,
• a destructor, or
• a function try block for a function with the return type (possibly cv-qualified) void

without encountering a return statement, return; is executed.

If control reaches the end of the main function, return 0; is executed.

Flowing off the end of a value-returning function, except the main function and specific coroutines(since C++20), without a return statement is undefined behavior.

In a function returning (possibly cv-qualified) void, the return statement with expression can be used, if the expression type is (possibly cv-qualified) void.

If the return type of a function is specified as a placeholder type, it will be deduced from the return value. If decltype(auto) is used, the type deduction treats an expression that can be an entity as an entity.

Returning by value may involve construction and copy/move of a temporary object, unless copy elision is used. Specifically, the conditions for copy/move are as follows:

The expression is move-eligible if it is a (possibly parenthesized) identifier expression that names a variable of automatic storage duration whose type is

• a non-volatile object type

• or a non-volatile rvalue reference to object type

and that variable is declared

• in the body
• or as a parameter

of the innermost enclosing function or lambda expression.

If the expression is move-eligible, overload resolution to select the constructor to use for initialization of the returned value or, for co_return, to select the overload of promise.return_value()(since C++20) is performed twice :

• first as if expression were an rvalue expression (thus it may select the move constructor), and

• if the first overload resolution failed

• or it succeeded, but did not select the move constructor (formally, the first parameter of the selected constructor was not an rvalue reference to the (possibly cv-qualified) type of expression)

• then overload resolution is performed as usual, with expression considered as an lvalue (so it may select the copy constructor).

If the expression is move-eligible, it is treated as an xvalue (thus overload resolution may select the move constructor).

If expression is a prvalue, the result object is initialized directly by that expression. This does not involve a copy or move constructor when the types match (see copy elision).

return, co_return

#include <iostream>
#include <string>
#include <utility>
 
void fa(int i)
{
    if (i == 2)
        return;
    std::cout << "fa("<< i << ")\n";
} // implied return;
 
int fb(int i)
{
    if (i > 4)
        return 4;
    std::cout << "fb(" << i << ")\n";
    return 2;
}
 
std::pair<std::string, int> fc(const char* p, int x)
{
    return {p, x};
}
 
void fd()
{
    return fa(10); // fa(10) is a void expression
}
 
int main()
{
    fa(1); // prints its argument, then returns
    fa(2); // does nothing when i == 2, just returns
 
    int i = fb(5); // returns 4
    i = fb(i);     // prints its argument, returns 2
    std::cout << "i = " << i << '\n'
              << "fc(~).second = " << fc("Hello", 7).second << '\n';
 
    fd();
}
 
struct MoveOnly
{
    MoveOnly() = default;
    MoveOnly(MoveOnly&&) = default;
};
 
MoveOnly move_11(MoveOnly arg)
{
    return arg; // OK. implicit move
}
 
MoveOnly move_11(MoveOnly&& arg)
{
    return arg; // OK since C++20. implicit move
}
 
MoveOnly&& move_23(MoveOnly&& arg)
{
    return arg; // OK since C++23. implicit move
}

Output:

fa(1)
fb(4)
i = 2
fc(~).second = 7
fa(10)

The following behavior-changing defect reports were applied retroactively to previously published C++ standards.

• copy elision

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4