Base de connaissancesCentre d’examen
FRFrançais
Choisir la langue13

CKTIS / C++

Déplacement implicite d’un paramètre dans un return

En C++23, `return a;` peut déplacer un paramètre passé par valeur. Ce n’est pas de la NRVO : le paramètre et le résultat sont deux objets distincts.

Version : ISO C++23; implementation support may vary

Syntaxe

template<class T>
T relay(T a) {
    return a;
}

Avec un paramètre par valeur T a, la fonction dispose de son propre objet. Initialiser a depuis l’argument et initialiser le résultat sont deux étapes distinctes. En C++23, dans return a;, le nom d’un paramètre admissible est une xvalue : il désigne un objet existant dont on peut déplacer la valeur. Dans les usages ordinaires, a reste une lvalue.

La règle vise le nom, éventuellement parenthésé, d’une variable à durée de stockage automatique déclarée dans la fonction ou le lambda courant : un objet non volatile ou une référence rvalue vers un tel objet. Elle ne s’applique ni aux paramètres de type référence lvalue ni aux expressions comme a.member.

La résolution de surcharge peut choisir T(T&&) ou T(const T&). Par exemple, une source de type const T peut se lier à const T&, mais pas à T&&. Si le constructeur sélectionné est supprimé ou inaccessible, le code est mal formé. Le déplacement implicite depuis un paramètre par valeur existe depuis C++11. En C++20, pour un retour par valeur, un échec de résolution avec une rvalue pouvait entraîner un nouvel essai avec une lvalue ; en C++23, ce second essai n’existe plus.

La NRVO permet de construire directement comme résultat un objet local nommé, non volatile et à durée de stockage automatique, si son type de classe correspond au type de retour à la qualification cv près. Elle est facultative et exclut les paramètres. Depuis C++17, return T{};, avec un type de retour T, initialise le résultat directement à partir d’une prvalue, sans copie ni déplacement. Ici, préférer return a; : std::move(a) est superflu pour le paramètre, et appliquer std::move à un objet local admissible empêche la NRVO en C++23.

Renvoyer T plutôt que T&& si le résultat doit survivre au paramètre : la référence renvoyée ne prolonge pas la vie du paramètre. La prise en charge de C++23 varie ; vérifier que __cpp_implicit_move est définie et vaut au moins 202207L.

Exemples

#include <iostream>

struct Token {
    Token() = default;
    Token(const Token&) { std::cout << "copy\n"; }
    Token(Token&&) { std::cout << "move\n"; }
};

Token relay(Token a) {
    return a;
}

int main() {
    Token input;
    Token result = relay(input);
    (void)result;
}

Résultat

copy
move

`copy` correspond à l’initialisation de `a` depuis la lvalue `input`, et `move` à la construction de `result` depuis `a` dans `return a;`. Il n’y a pas de troisième opération. Cette sortie ne distingue pas C++23 des modes plus anciens.

Leçons associées

  • C++ · Leçon 14 · Avancé · Version : 3

Sources