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

CKTIS / C++

Construction directe de l’objet résultat à partir d’une prvalue

Depuis C++17, une prvalue du même type classe construit directement le résultat, sans copier ni déplacer l’objet entier. La NRVO reste facultative et les données membres peuvent être copiées.

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

Syntaxe

T make() { return T{args}; }  // same-type prvalue: constructs the result directly
T value = make();             // initialization, not assignment
T make_named() { T local{args}; return local; }  // optional NRVO

Depuis C++17, y compris en C++23, return T{args}; dans une fonction qui renvoie T par valeur construit directement l’objet résultat. T{args} est une prvalue du même type classe que le résultat, à const et volatile près. Il n’existe pas d’objet temporaire T distinct à copier ou à déplacer. « Élision garantie de copie » est le nom courant de cette règle du langage, et non d’une optimisation facultative.

Dans T value = make();, value est l’objet résultat de l’appel qui renvoie T par valeur. Le signe = dans cette déclaration indique une initialisation, pas une affectation. Même l’expression « initialisation par copie » n’implique pas l’appel d’un constructeur de copie. Si T{args} sélectionne un constructeur de T, celui-ci doit être utilisable. Si T est un agrégat, T{args} peut à la place effectuer une initialisation d’agrégat sans appeler de constructeur de T. Le destructeur de T doit être accessible au point du return et ne pas être supprimé. Ne supposez pas que la même garantie s’applique à un sous-objet de classe de base.

return OrderBatch{kOrders}; ne copie ni ne déplace un OrderBatch entier. Cela n’empêche pas la copie des données d’entrée : dans l’exemple, orders(source) copie le std::string de kOrders dans un membre propre au résultat. L’objet local kOrders est détruit à la sortie de la fonction, et batch à la sortie de son bloc dans main.

Avec return local;, l’optimisation de la valeur de retour nommée (NRVO) est autorisée mais facultative si local est un objet local nommé, non volatile, à durée de stockage automatique et du même type classe (à qualification cv près), hors paramètres de fonction ou de gestionnaire d’exception. Avec la NRVO, l’objet local et le résultat ne font qu’un. En C++23, la résolution de surcharge traite cet opérande comme une xvalue et peut sélectionner un déplacement ou une copie. Si aucun constructeur utilisable n’est sélectionné, le retour est mal formé, même si la NRVO serait possible.

Exemples

#include <iostream>
#include <string>

struct OrderBatch {
    std::string orders;

    explicit OrderBatch(const std::string& source) : orders(source) {}
    OrderBatch(const OrderBatch&) = delete;
    OrderBatch(OrderBatch&&) = delete;
};

OrderBatch make_batch() {
    const std::string kOrders{"order-42"};
    return OrderBatch{kOrders};
}

int main() {
    OrderBatch batch = make_batch();
    std::cout << batch.orders << '\n';
}

Résultat

order-42

Le programme devrait afficher `order-42`. Les constructeurs de copie et de déplacement de `OrderBatch` sont supprimés, mais pas le constructeur de copie de `std::string`. Remplacer le retour de la prvalue par `OrderBatch local{kOrders}; return local;` devrait produire une erreur de compilation.

Leçons associées

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

Sources