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

CKTIS / C++

Élimination de copie, NRVO et déplacement implicite

Distinguez la construction garantie à partir d’une prvalue, la NRVO facultative et le déplacement implicite en C++23. Un retour par valeur n’implique pas nécessairement une copie, mais la correction du programme ne doit pas dépendre de l’application de la NRVO.

Version : C++23; repository compiler flag, production runtime not attested

Syntaxe

T direct() { return T{}; }
T named() { T local; return local; }
T forward_value(T value) { return value; }

L’élimination de copie permet, dans certaines circonstances, d’omettre une construction par copie ou par déplacement, même si cela modifie les effets observables des constructeurs et des destructeurs. Ne fondez pas la logique du programme sur le nombre de ces appels.

L’élimination de copie garantie est le nom courant des règles relatives aux prvalues qui s’appliquent depuis C++17. Dans T direct() { return T{}; }, le résultat est construit directement dans l’objet de destination du même type, en ignorant les qualificatifs cv lors de la comparaison des types. Il ne s’agit pas d’une NRVO facultative : aucun constructeur de copie ou de déplacement n’est nécessaire, mais le destructeur doit être accessible et non supprimé.

La NRVO (named return value optimization) peut s’appliquer à return local; lorsque local est un objet automatique non volatile du type approprié, et non un paramètre de fonction ou une variable de gestionnaire d’exception. En C++23, la NRVO reste facultative ; les exigences relatives au constructeur sélectionné s’appliquent toujours. Écrire return std::move(local); ne respecte pas l’exigence de la NRVO selon laquelle l’expression doit désigner l’objet.

Le déplacement implicite n’omet pas la construction. En C++23, une expression admissible au déplacement est traitée comme une xvalue ; cela comprend les retours courants d’objets locaux ou de paramètres passés par valeur. La résolution de surcharge peut sélectionner un constructeur de déplacement ou une copie disponible prenant const T& ; si le constructeur de déplacement sélectionné est supprimé, cela provoque une erreur, sans nouvelle tentative de copie. forward_value illustre un paramètre : il ne peut pas bénéficier de la NRVO, mais prend en charge le déplacement implicite. Cette entrée décrit C++23 ; les pages citées sont un projet en évolution, et non une édition C++23 figée.

Identifiants de référence couverts par cette entrée : Copy elision, NRVO and implicit move.

Exemples

#include <iostream>

struct T {
    int value;
    explicit T(int n = 0) : value(n) {}
    T(const T&) = delete;
    T(T&&) = default;
};

T direct() {
    return T{10};
}

T named() {
    T local{20};
    return local;
}

T forward_value(T value) {
    return value;
}

int main() {
    T a = direct();
    T b = named();
    T c = forward_value(T{30});
    std::cout << a.value << ' ' << b.value << ' ' << c.value << '\n';
}

Résultat

10 20 30

Le code affiché et le résultat déclaré ont été vérifiés dans un environnement isolé selon la méthode consignée dans la preuve de vérification de cette version exacte.

Sources