Copy elision

• Dans une throw expression , lorsque l'opérande est le nom d'un objet non volatile obj avec une durée de stockage automatique (autre qu'un paramètre de fonction ou un paramètre de gestionnaire) qui appartient à une portée qui ne contient pas le bloc try englobant le plus interne (s'il existe), l'initialisation par copie de l'objet exception peut être omise en construisant obj directement dans l'objet exception.
• Dans un gestionnaire , l'initialisation par copie de l'argument du gestionnaire peut être omise en traitant le paramètre du gestionnaire comme un alias de l'objet exception si la signification du programme reste inchangée, à l'exception de l'exécution des constructeurs et destructeurs pour l'argument du gestionnaire.

• Dans les coroutines , une copie d'un paramètre de coroutine peut être omise. Dans ce cas, les références à cette copie sont remplacées par des références au paramètre correspondant si la signification du programme reste inchangée, à l'exception de l'exécution d'un constructeur et destructeur pour l'objet copie du paramètre.

Si le premier paramètre du constructeur sélectionné est une référence à une valeur de déplacement (rvalue reference) du type de l'objet, la destruction de cet objet se produit lorsque la cible aurait été détruite. Sinon, la destruction se produit au moment le plus tardif entre les deux moments où les deux objets auraient été détruits sans l'optimisation.

Sémantique des prvalues ("suppression de copie garantie")

Depuis C++17, une prvalue n'est pas matérialisée avant d'être nécessaire, puis elle est construite directement dans le stockage de sa destination finale. Cela signifie parfois que même lorsque la syntaxe du langage suggère visuellement une copie/déplacement (par ex. l'initialisation par copie ), aucune copie/déplacement n'est effectué — ce qui signifie que le type n'a pas besoin de posséder un constructeur de copie/déplacement accessible. Les exemples incluent :

• L'initialisation de l'objet retourné dans une instruction return , lorsque l'opérande est une prvalue du même type de classe (en ignorant la qualification cv ) que le type de retour de la fonction :

T f()
{
    return U(); // constructs a temporary of type U,
                // then initializes the returned T from the temporary
}
T g()
{
    return T(); // constructs the returned T directly; no move
}

Le destructeur du type retourné doit être accessible au point de l'instruction return et non supprimé, même si aucun objet T n'est détruit.

• Dans l'initialisation d'un objet, lorsque l'expression d'initialisation est une prvalue du même type de classe (en ignorant la qualification cv ) que le type de la variable :

T x = T(T(f())); // x is initialized by the result of f() directly; no move

Ceci ne peut s'appliquer que lorsque l'objet initialisé est connu pour ne pas être un sous-objet potentiellement chevauchant :

struct C { /* ... */ };
C f();
struct D;
D g();
struct D : C
{
    D() : C(f()) {}    // no elision when initializing a base class subobject
    D(int) : D(g()) {} // no elision because the D object being initialized might
                       // be a base-class subobject of some other class
};

Remarque : Cette règle ne spécifie pas une optimisation, et la Norme ne la décrit pas formellement comme une "suppression de copie" (car rien n'est supprimé). Au lieu de cela, la spécification du langage cœur de C++17 concernant les prvalues et les temporaires est fondamentalement différente de celle des révisions antérieures de C++ : il n'y a plus de temporaire à partir duquel copier/déplacer. Une autre façon de décrire la mécanique de C++17 est le "passage de valeur non matérialisée" ou la "matérialisation temporaire différée" : les prvalues sont retournées et utilisées sans jamais matérialiser de temporaire.

Dans une instruction return ou une expression throw , si le compilateur ne peut pas réaliser l'élision de copie mais que les conditions pour l'élision de copie sont remplies, ou le seraient sauf que la source est un paramètre de fonction, le compilateur tentera d'utiliser le constructeur de déplacement même si l'opérande source est désignée par un lvalue (jusqu'à C++23) l'opérande source sera traitée comme un rvalue (depuis C++23) ; voir l'instruction return pour plus de détails.

Dans les expressions constantes et l' initialisation constante , l'élision de copie n'est jamais effectuée.

struct A
{
    void* p;
    constexpr A() : p(this) {}
    A(const A&); // Disable trivial copyability
};
constexpr A a;  // OK: a.p points to a
constexpr A f()
{
    A x;
    return x;
}
constexpr A b = f(); // error: b.p would be dangling and point to the x inside f
constexpr A c = A(); // (until C++17) error: c.p would be dangling and point to a temporary
                     // (since C++17) OK: c.p points to c; no temporary is involved