Espaces de noms
Variantes
Affichages
Actions

copy elision

De cppreference.com
< cpp‎ | language

 
 
Langage C++
Sujets généraux
Contrôle de flux
Instructions conditionnelles
Instructions d'itération
Instructions de saut
Fonctions
déclaration de fonction
expression lambda
fonction générique
spécificateur inline
spécification d'exception (obsolète)
spécificateur noexcept (C++11)
Exceptions
Espaces de noms
Types
spécificateur decltype (C++11)
Qualificatifs
qualificatifs const et volatile
qualificatifs de stockage
qualificatif constexpr (C++11)
qualificatif auto (C++11)
qualificatif alignas (C++11)
Initialisation
Littéraux
Expressions
opérateurs alternatifs
Utilitaires
Types
déclaration typedef
déclaration d'alias de type (C++11)
attributs (C++11)
Jette
Original:
Casts
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
conversions implicites
conversion const_cast
conversion static_cast
conversion dynamic_cast
conversion reinterpret_cast
conversions style C et style fonction
Allocation de mémoire
Classes
Qualificatifs spécifiques aux membres de classe
Fonctions membres spéciales
Modèles
classes génériques
fonctions génériques
spécialisation de modèles
paquets de paramètres (C++11)
Divers
Assembleur
 
Optimise les copier-déplacer-constructeurs, ce qui entraîne zéro-copie passage par valeur sémantique .
Original:
Optimizes out copy- and move-constructors, resulting in zero-copy pass-by-value semantics.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

Sommaire

[modifier] Explication

Dans les cas suivants, les compilateurs sont autorisées à omettre le copier-déplacer-constructeurs des objets de la classe, même si la copie / déplacement constructeur et le destructeur sont observables effets secondaires .
Original:
Under the following circumstances, the compilers are permitted to omit the copy- and move-constructors of class objects even if copy/move constructor and the destructor have observable side-effects.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
  • Si une fonction renvoie un type de classe par valeur, et l'expression de la déclaration return est le nom d'un objet non-volatile avec la durée de stockage automatique, ce qui n'est pas le paramètre de fonction ou un paramètre clause catch, et qui a la même cv- type non qualifié comme type de retour de la fonction, puis copier / déplacer est omise. Lorsque cette variable locale est construite, il est construit directement dans le stockage où la valeur de retour de la fonction, autrement, seraient déplacés ou copiés. Cette variante de l'élision copie est connu sous le nom NRVO », du nom optimisation de la valeur de retour" .
    Original:
    If a function returns a class type by value, and the return statement's expression is the name of a non-volatile object with automatic storage duration, which isn't the function parameter, or a catch clause parameter, and which has the same cv-unqualified type as the return type of the function, then copy/move is omitted. When that local variable is constructed, it is constructed directly in the storage where the function's return value would otherwise be moved or copied to. This variant of copy elision is known as NRVO, "named return value optimization".
    The text has been machine-translated via Google Translate.
    You can help to correct and verify the translation. Click here for instructions.
  • Lorsqu'un temporaire sans nom, n'est lié à aucune références, serait déplacé ou copié dans un objet de la même cv-non qualifié type, la copie / déplacement est omis. Lorsque que temporaire est construit, il est construit directement dans le stockage où il serait autrement être déplacé ou copié. Lorsque le temporaire sans nom est l'argument d'une instruction de retour, cette variante de l'élision copie est connu sous le nom RVO, «retourner optimisation de la valeur" .
    Original:
    When a nameless temporary, not bound to any references, would be moved or copied into an object of the same cv-unqualified type, the copy/move is omitted. When that temporary is constructed, it is constructed directly in the storage where it would otherwise be moved or copied to. When the nameless temporary is the argument of a return statement, this variant of copy elision is known as RVO, "return value optimization".
    The text has been machine-translated via Google Translate.
    You can help to correct and verify the translation. Click here for instructions.
  • Dans un jet d'expression, si l'opérande est le nom d'un objet non-volatile avec la durée de stockage automatique, ce qui n'est pas le paramètre de fonction ou un paramètre clause catch, et dont la portée ne dépasse pas du plus profond essayez-bloc ( s'il existe un essai-bloc), puis copie / déplacement est omis. Lorsque cette variable locale est construite, il est construit directement dans le stockage où l'objet exception, autrement, seraient déplacés ou copiés. (depuis C++11)
    Original:
    In a throw-expression, if the operand is the name of a non-volatile object with automatic storage duration, which isn't the function parameter, or a catch clause parameter, and whose scope does not extend past the innermost try-block (if there is a try-block), then copy/move is omitted. When that local variable is constructed, it is constructed directly in the storage where the exception object would otherwise be moved or copied to. (depuis C++11)
    The text has been machine-translated via Google Translate.
    You can help to correct and verify the translation. Click here for instructions.
  • Lorsque vous manipulez une exception, si l'argument de la clause catch est du même type (à l'exception des cv-qualification) que l'objet exception est lancée, le copier / déplacer est omis et le corps de la clause catch accède à l'objet d'exception, comme si elle a été passée par référence. (depuis C++11)
    Original:
    When handling an exception, if the argument of the catch clause is of the same type (except for cv-qualification) as the exception object thrown, the copy/move is omitted and the body of the catch clause accesses the exception object directly, as if it was passed by reference. (depuis C++11)
    The text has been machine-translated via Google Translate.
    You can help to correct and verify the translation. Click here for instructions.
Élisions copies multiples peuvent être enchaînés pour supprimer les copies multiples .
Original:
Multiple copy elisions may be chained to eliminate multiple copies.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

[modifier] Notes

Copier élision est la seule forme autorisée d'optimisation qui peuvent modifier les effets secondaires observables. Parce que certains compilateurs n'effectuent pas élision copie dans toutes les situations où il est permis, programmes qui reposent sur les effets secondaires de copier / déplacer des constructeurs et destructeurs sont pas portables .
Original:
Copy elision is the only allowed form of optimization that can change the observable side-effects. Because some compilers do not perform copy elision in every situation where it is allowed, programs that rely on the side-effects of copy/move constructors and destructors are not portable.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
Même lorsque l'élision copie a lieu et le copy-/move-constructor n'est pas appelé, il doit être présent et accessible, sinon le programme est mal formé .
Original:
Even when copy elision takes place and the copy-/move-constructor is not called, it must be present and accessible, otherwise the program is ill-formed.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

[modifier] Exemple

#include <vector>
#include <iostream>
 
struct Noisy {
    Noisy() {std::cout << "constructed\n"; }
    Noisy(const Noisy&) { std::cout << "copied\n"; }
    Noisy(Noisy&&) { std::cout << "moved\n"; }
    ~Noisy() {std::cout << "destructed\n"; }
};
 
std::vector<Noisy> f()
{
    std::vector<Noisy> v = std::vector<Noisy>(3); // copy elision from temporary to v
    return v; // NRVO from v to the nameless temporary that is returned
}
 
void fn_by_val(std::vector<Noisy> arg)
{
    std::cout << "arg.size() = " << arg.size() << '\n';
}
 
int main()
{
    std::vector<Noisy> v = f(); // copy elision from returned temporary to v
    fn_by_val(f());             // and from temporary to the argument of fn_by_val()
}

Résultat possible :

constructed
constructed
constructed
constructed
constructed
constructed
arg.size() = 3
destructed
destructed
destructed
destructed
destructed
destructed

[modifier] Voir aussi