return statement

Termina la función actual y devuelve el valor especificado (si lo hay) al llamador.

Sintaxis

Explicación

La expresión o lista-de-inicialización-entre-llaves (desde C++11) (si existe) se conoce como el operando de la sentencia return .

Si el control llega al final de

• una función con el tipo de retorno (posiblemente calificado cv) void ,
• un constructor,
• un destructor, o
• un bloque try de función para una función con el tipo de retorno (posiblemente calificado cv) void

sin encontrar una return statement, return ; se ejecuta.

Si el control alcanza el final de la main función , return 0 ; se ejecuta.

Salir del final de una función que retorna un valor, excepto la función main y ciertas corrutinas (desde C++20) , sin una sentencia return es comportamiento indefinido.

En una función que retorna (posiblemente calificado con cv) void , la sentencia return con expresión puede ser utilizada, si el tipo de la expresión es (posiblemente calificado con cv) void .

Notas

Retornar por valor puede involucrar la construcción y copia/traslado de un objeto temporal, a menos que se utilice copy elision . Específicamente, las condiciones para copia/traslado son las siguientes:

Palabras clave

return , co_return

Ejemplo

#include <iostream>
#include <string>
#include <utility>
void fa(int i)
{
    if (i == 2)
        return;
    std::cout << "fa("<< i << ")\n";
} // retorno implícito;
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) es una expresión void
}
int main()
{
    fa(1); // imprime su argumento, luego retorna
    fa(2); // no hace nada cuando i == 2, solo retorna
    int i = fb(5); // retorna 4
    i = fb(i);     // imprime su argumento, retorna 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. movimiento implícito
}
MoveOnly move_11(MoveOnly&& arg)
{
    return arg; // OK desde C++20. movimiento implícito
}
MoveOnly&& move_23(MoveOnly&& arg)
{
    return arg; // OK desde C++23. movimiento implícito
}

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

Informes de defectos

Los siguientes informes de defectos que modifican el comportamiento se aplicaron retroactivamente a los estándares publicados anteriormente de C++.

Véase también

• omisión de copia