return statement

Met fin à la fonction actuelle et renvoie la valeur spécifiée (le cas échéant) à l'appelant.

Syntaxe

Explication

L' expression ou la liste d'initialisation entre accolades (depuis C++11) (le cas échéant) est appelée l' opérande de l'instruction return .

Si le contrôle atteint la fin de

• une fonction avec le type de retour (éventuellement qualifié cv) void ,
• un constructeur,
• un destructeur, ou
• un bloc try de fonction pour une fonction avec le type de retour (éventuellement qualifié cv) void

sans rencontrer d'instruction return , return ; est exécuté.

Si le contrôle atteint la fin de la main function , return 0 ; est exécuté.

Sortir de la fin d'une fonction retournant une valeur, à l'exception de la main function et des coroutines spécifiques (depuis C++20) , sans instruction return est un comportement indéfini.

Dans une fonction retournant (éventuellement qualifié cv) void , l'instruction return avec expression peut être utilisée, si le type de l'expression est (éventuellement qualifié cv) void .

Notes

Le retour par valeur peut impliquer la construction et la copie/déplacement d'un objet temporaire, à moins que copy elision ne soit utilisée. Plus précisément, les conditions pour la copie/le déplacement sont les suivantes :

Mots-clés

return , co_return

Exemple

#include <iostream>
#include <string>
#include <utility>
void fa(int i)
{
    if (i == 2)
        return;
    std::cout << "fa("<< i << ")\n";
} // retour implicite ;
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) est une expression void
}
int main()
{
    fa(1); // affiche son argument, puis retourne
    fa(2); // ne fait rien quand i == 2, retourne simplement
    int i = fb(5); // retourne 4
    i = fb(i);     // affiche son argument, retourne 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. déplacement implicite
}
MoveOnly move_11(MoveOnly&& arg)
{
    return arg; // OK depuis C++20. déplacement implicite
}
MoveOnly&& move_23(MoveOnly&& arg)
{
    return arg; // OK depuis C++23. déplacement implicite
}

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

Rapports de défauts

Les rapports de défauts modifiant le comportement suivants ont été appliqués rétroactivement aux normes C++ précédemment publiées.

Voir aussi

• élision de copie