Espaces de noms
Variantes
Affichages
Actions

Copy assignment operator

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
opérateur as
opérateur move (C++11)
destructeur
Modèles
classes génériques
fonctions génériques
spécialisation de modèles
paquets de paramètres (C++11)
Divers
Assembleur
 
Un opérateur d'affectation de copie T classe est une fonction non-template élément non-statique avec le nom operator= qui prend exactement un paramètre de type de T, T&, const T&, volatile T&, ou const volatile T&. Un type avec un opérateur d'affectation de copie publique est CopyAssignable .
Original:
A copy assignment operator of class T is a non-template non-static member function with the name operator= that takes exactly one parameter of type T, T&, const T&, volatile T&, or const volatile T&. A type with a public copy assignment operator is CopyAssignable.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

Sommaire

[modifier] Syntaxe

class_name & class_name :: operator= ( class_name ) (1) (depuis C++11)
class_name & class_name :: operator= ( const class_name & ) (2) (depuis C++11)
class_name & class_name :: operator= ( const class_name & ) = default; (3) (depuis C++11)
class_name & class_name :: operator= ( const class_name & ) = delete; (4) (depuis C++11)

[modifier] Explication

# Déclaration typique d'un opérateur d'affectation de copie lorsque copy-and-swap idiom peuvent être utilisés
Original:
# Typical declaration of a copy assignment operator when copy-and-swap idiom can be used
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
# Déclaration typique d'un opérateur d'affectation de copie lorsque idiome copier-swap ne peut pas être utilisé
Original:
# Typical declaration of a copy assignment operator when copy-and-swap idiom cannot be used
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
# Forcer un opérateur d'affectation de copie doit être généré par le compilateur
Original:
# Forcing a copy assignment operator to be generated by the compiler
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
# Éviter d'affectation de copie implicite
Original:
# Avoiding implicit copy assignment
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
L'opérateur d'affectation de copie est appelée chaque fois choisi par résolution de surcharge, par exemple, quand un objet apparaît sur le côté gauche d'une expression d'affectation .
Original:
The copy assignment operator is called whenever selected by résolution de surcharge, e.g. when an object appears on the left side of an assignment expression.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

[modifier] Implicitement, a déclaré l'opérateur d'affectation de copie

Si aucun définis par l'utilisateur copie des opérateurs d'affectation sont prévus pour un type de classe (struct, class ou union), le compilateur va toujours déclarer une comme membre en ligne publique de la classe. Cet opérateur copie implicitement déclaré affectation a la forme T& T::operator=(const T&) si toutes les conditions suivantes sont réunies:
Original:
If no user-defined copy assignment operators are provided for a class type (struct, class, or union), the compiler will always declare one as an inline public member of the class. This implicitly-declared copy assignment operator has the form T& T::operator=(const T&) if all of the following is true:
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
  • chaque base directe B de T a un opérateur d'affectation de copie dont les paramètres sont B ou const B& ou const volatile B&
    Original:
    each direct base B of T has a copy assignment operator whose parameters are B or const B& or const volatile B&
    The text has been machine-translated via Google Translate.
    You can help to correct and verify the translation. Click here for instructions.
  • chaque membre non statique de données M de T de type classe ou tableau de type classe a un opérateur d'affectation de copie dont les paramètres sont M ou const M& ou const volatile M&
    Original:
    each non-static data member M of T of class type or array of class type has a copy assignment operator whose parameters are M or const M& or const volatile M&
    The text has been machine-translated via Google Translate.
    You can help to correct and verify the translation. Click here for instructions.
Sinon, l'opérateur copie implicitement déclaré affectation est déclarée comme T& T::operator=(T&). (Notez qu'en raison de ces règles, l'opérateur copie implicitement déclaré affectation ne peut pas se lier à un argument volatile lvalue)
Original:
Otherwise the implicitly-declared copy assignment operator is declared as T& T::operator=(T&). (Note that due to these rules, the implicitly-declared copy assignment operator cannot bind to a volatile lvalue argument)
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
Une classe peut avoir plusieurs opérateurs d'affectation copie, par exemple à la fois T& T::operator=(const T&) et T& T::operator=(T). Si certains définies par l'utilisateur copie des opérateurs d'affectation sont présents, l'utilisateur peut toujours forcer la génération de l'opérateur d'affectation de copie implicitement déclarée avec le mot-clé default .
Original:
A class can have multiple copy assignment operators, e.g. both T& T::operator=(const T&) and T& T::operator=(T). If some user-defined copy assignment operators are present, the user may still force the generation of the implicitly declared copy assignment operator with the keyword default.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
Parce que l'opérateur d'affectation de copie est toujours fixée pour toute la classe, l'opérateur d'affectation de classe de base est toujours caché. Si une aide-déclaration est utilisée pour amener l'opérateur d'affectation dans la classe de base, et de son type d'argument pourrait être le même que le type d'argument de l'opérateur d'affectation implicite de la classe dérivée, l'aide-déclaration est également masquée par l'implicite déclaration .
Original:
Because the copy assignment operator is always declared for any class, the base class assignment operator is always hidden. If a using-declaration is used to bring in the assignment operator from the base class, and its argument type could be the same as the argument type of the implicit assignment operator of the derived class, the using-declaration is also hidden by the implicit declaration.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

[modifier] Supprimé implicitement déclarée opérateur d'affectation de copie

L'opérateur copie implicitement déclarée ou défaut d'affectation pour T classe est définie comme' supprimés dans l'une des conditions suivantes est remplie:
Original:
The implicitly-declared or defaulted copy assignment operator for class T is defined as deleted in any of the following is true:
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
  • T a un membre non statique de données qui est const
    Original:
    T has a non-static data member that is const
    The text has been machine-translated via Google Translate.
    You can help to correct and verify the translation. Click here for instructions.
  • T a un membre non statique de données d'un type de référence .
    Original:
    T has a non-static data member of a reference type.
    The text has been machine-translated via Google Translate.
    You can help to correct and verify the translation. Click here for instructions.
  • T a un membre non statique de données qui ne peut pas être la copie affecté (a supprimé, opérateur inaccessible, ou ambigu, affectation par copie)
    Original:
    T has a non-static data member that cannot be copy-assigned (has deleted, inaccessible, or ambiguous copy assignment operator)
    The text has been machine-translated via Google Translate.
    You can help to correct and verify the translation. Click here for instructions.
  • T a de la classe de base directe ou virtuelle qui ne peut pas être la copie affecté (a supprimé, inaccessible, ou ambigus opérateur d'affectation mouvement)
    Original:
    T has direct or virtual base class that cannot be copy-assigned (has deleted, inaccessible, or ambiguous move assignment operator)
    The text has been machine-translated via Google Translate.
    You can help to correct and verify the translation. Click here for instructions.
  • T a une interface déclarée constructeur déménagement
    Original:
    T has a user-declared move constructor
    The text has been machine-translated via Google Translate.
    You can help to correct and verify the translation. Click here for instructions.
  • T a une interface déclarée opérateur d'affectation mouvement
    Original:
    T has a user-declared move assignment operator
    The text has been machine-translated via Google Translate.
    You can help to correct and verify the translation. Click here for instructions.

[modifier] Trivial opérateur d'affectation de copie

L'opérateur copie implicitement déclaré cession T classe est triviale si l'ensemble des conditions suivantes est remplie:
Original:
The implicitly-declared copy assignment operator for class T is trivial if all of the following is true:
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
  • T n'a pas de fonctions membres virtuelles
    Original:
    T has no virtual member functions
    The text has been machine-translated via Google Translate.
    You can help to correct and verify the translation. Click here for instructions.
  • T a pas de classes de base virtuelles
    Original:
    T has no virtual base classes
    The text has been machine-translated via Google Translate.
    You can help to correct and verify the translation. Click here for instructions.
  • L'opérateur d'affectation de copie sélectionné pour chaque base directe de T est trivial
    Original:
    The copy assignment operator selected for every direct base of T is trivial
    The text has been machine-translated via Google Translate.
    You can help to correct and verify the translation. Click here for instructions.
  • L'opérateur d'affectation de copie sélectionné pour chaque type de classe non statique (ou un tableau de type de classe) memeber de T est trivial
    Original:
    The copy assignment operator selected for every non-static class type (or array of class type) memeber of T is trivial
    The text has been machine-translated via Google Translate.
    You can help to correct and verify the translation. Click here for instructions.
Un opérateur de copie trivial affectation effectue une copie de la représentation de l'objet comme par std::memmove. Tous les types de données compatibles avec le langage C (types POD) sont trivialement copie cessible .
Original:
A trivial copy assignment operator makes a copy of the object representation as if by std::memmove. All data types compatible with the C language (POD types) are trivially copy-assignable.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

[modifier] Implicitement défini par l'opérateur d'affectation de copie

Si l'opérateur copie implicitement déclaré affectation n'est pas supprimé ou trivial, il est défini (c'est-à-corps d'une fonction est généré et compilé) par le compilateur. Pour les types de union, l'affectation de copie de définition implicite copie la représentation de l'objet (comme par std::memmove). Pour les types de classes non syndiqués (class et struct), l'opérateur effectue affectation de copie membres sage de bases de l'objet et non-membres statiques, dans leur ordre d'initialisation, en utilisant, grâce à la prise en mission pour les scalaires et opérateurs d'assignation de copie pour types de classes .
Original:
If the implicitly-declared copy assignment operator is not deleted or trivial, it is defined (that is, a function body is generated and compiled) by the compiler. For union types, the implicitly-defined copy assignment copies the object representation (as by std::memmove). For non-union class types (class and struct), the operator performs member-wise copy assignment of the object's bases and non-static members, in their initialization order, using, using built-in assignment for the scalars and copy assignment operator for class types.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
La génération de l'opérateur d'affectation de copie de définition implicite est deprecated (depuis C++11) si T a un destructeur utilisateur déclaré ou déclaré par l'utilisateur constructeur de copie .
Original:
The generation of the implicitly-defined copy assignment operator is deprecated (depuis C++11) if T has a user-declared destructor or user-declared copy constructor.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

[modifier] Notes

Si les deux copies et les opérateurs d'affectation mouvements sont prévus, la résolution de surcharge sélectionne l'affectation déménagement, si l'argument est un' rvalue (soit' prvalue comme un temporaire sans nom ou xValue comme le résultat d'std::move ), et sélectionne l'assignation copie si l'argument est lvalue' (du nom de l'objet ou une fonction / retour lvalue opérateur de référence). Si seulement l'affectation de copie est fournie, toutes les catégories d'arguments sélectionnez-le (dans la mesure où il tire son argument par valeur ou référence à const, depuis rvalues ​​peut se lier à des références const), ce qui rend l'affectation de copie de secours pour l'affectation mouvement, quand se déplacer n'est pas disponible .
Original:
If both copy and move assignment operators are provided, overload resolution selects the move assignment if the argument is an rvalue (either prvalue such as a nameless temporary or xvalue such as the result of std::move), and selects the copy assignment if the argument is lvalue (named object or a function/operator returning lvalue reference). If only the copy assignment is provided, all argument categories select it (as long as it takes its argument by value or as reference to const, since rvalues can bind to const references), which makes copy assignment the fallback for move assignment, when move is unavailable.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

[modifier] Copiez et échanger

Opérateur d'affectation de copie peut être exprimée en termes de constructeur de copie, le destructeur et le swap () fonction membre, s'il en est prévu:
Original:
Copy assignment operator can be expressed in terms of copy constructor, destructor, and the swap() member function, if one is provided:
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

T& T::operator=(T arg) { // copy/move constructor is called to construct arg
    swap(arg);    // resources exchanged between *this and arg
    return *this;
}  // destructor is called to release the resources formerly held by *this

Pour les non-jets de swap (), cette forme fournit garantie exception fort. Pour les arguments rvalue, cette forme appelle automatiquement le constructeur de déplacement, et est parfois appelé «opérateur d'affectation fédérateur» (comme dans, à la fois copie et déplacement) .
Original:
For non-throwing swap(), this form provides garantie exception fort. For rvalue arguments, this form automatically invokes the move constructor, and is sometimes referred to as "unifying assignment operator" (as in, both copy and move).
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 <iostream>
#include <memory>
struct A {
    int n;
    std::string s1;
    // user-defined copy assignment, copy-and-swap form
    A& operator=(A other) {
        std::cout << "copy assignment of A\n";
        std::swap(n, other.n);
        std::swap(s1, other.s1);
        return *this;
    }
};
 
struct B : A {
    std::string s2;
    // implicitly-defined copy assignment
};
 
struct C {
     std::unique_ptr<int[]> data;
     std::size_t size;
     // non-copy-and-swap assignment
     C& operator=(const C& other) {
         // check for self-assignment
         if(&other == this)
             return *this;
         // reuse storage when possible
         if(size != other.size)
             data.reset(new int[other.size]);
         std::copy(&other.data[0],
                   &other.data[0] + std::min(size, other.size),
                   &data[0]);
         return *this;
     }
     // note: copy-and-swap would always cause a reallocation
};
 
int main()
{
    A a1, a2;
    std::cout << "a1 = a2 calls ";
    a1 = a2; // user-defined copy assignment
 
    B b1, b2;
    b2.s1 = "foo";
    b2.s2 = "bar";
    std::cout << "b1 = b2 calls ";
    b1 = b2; // implicitly-defined copy assignment
    std::cout << "b1.s1 = " << b1.s1 << " b1.s2 = " << b1.s2 <<  '\n';
}

Résultat :

a1 = a2 calls copy assignment of A
b1 = b2 calls copy assignment of A
b1.s1 = foo b1.s2 = bar