Assignment operators

De cppreference.com

This page has been machine-translated from the English version of the wiki using Google Translate.

The translation may contain errors and awkward wording. Hover over text to see the original version. You can help to fix errors and improve the translation. For instructions click here.

Click here for the English version of this page

Les opérateurs d'affectation modifier la valeur de l'objet .

Operator name	Syntax	Overloadable	Prototype examples (for class T)
Operator name	Syntax	Overloadable	Inside class definition	Outside class definition
basic assignment	`a = b`	Yes	T& T::operator =(const T2& b);	N/A
move assignment (C++11)	`a = rvalue`	Yes	T& T::operator =(T2&& b);	N/A
addition assignment	`a += b`	Yes	T& T::operator +=(const T2& b);	T& operator +=(T& a, const T2& b);
subtraction assignment	`a -= b`	Yes	T& T::operator -=(const T2& b);	T& operator -=(T& a, const T2& b);
multiplication assignment	`a *= b`	Yes	T& T::operator *=(const T2& b);	T& operator *=(T& a, const T2& b);
division assignment	`a /= b`	Yes	T& T::operator /=(const T2& b);	T& operator /=(T& a, const T2& b);
modulo assignment	`a %= b`	Yes	T& T::operator %=(const T2& b);	T& operator %=(T& a, const T2& b);
bitwise AND assignment	`a &= b`	Yes	T& T::operator &=(const T2& b);	T& operator &=(T& a, const T2& b);
bitwise OR assignment	`a \|= b`	Yes	T& T::operator \|=(const T2& b);	T& operator \|=(T& a, const T2& b);
bitwise XOR assignment	`a ^= b`	Yes	T& T::operator ^=(const T2& b);	T& operator ^=(T& a, const T2& b);
bitwise left shift assignment	`a <<= b`	Yes	T& T::operator <<=(const T2& b);	T& operator <<=(T& a, const T2& b);
bitwise right shift assignment	`a >>= b`	Yes	T& T::operator >>=(const T2& b);	T& operator >>=(T& a, const T2& b);
'Note' Original: Notes The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions. Tous intégrés dans l'affectation des opérateurs retourner this, et la plupart définies par l'utilisateur surcharges également revenir this de sorte que les opérateurs définis par l'utilisateur peut être utilisé de la même manière que le haut-ins. Cependant, définie par l'utilisateur surcharge d'opérateur, n'importe quel type peut être utilisé comme type de retour (y compris void) . Original: All built-in assignment operators return this, and most user-defined overloads also return this so that the user-defined operators can be used in the same manner as the built-ins. However, in a user-defined operator overload, any type can be used as return type (including void). The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions. `T2` peuvent être de tout type, y compris `T` Original: `T2` can be any type including `T` 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

D'affectation de copie' opérateur remplace le contenu de la a objet avec une copie du contenu de b (b n'est modifié). Pour les types de classe, il s'agit d'une fonction membre particulière, décrite dans copier opérateur d'affectation .
Original:
copy assignment operator replaces the contents of the object a with a copy of the contents of b (b is no modified). For class types, this is a special member function, described in copier opérateur d'affectation.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

Affectation mouvement' opérateur remplace le contenu de la a objet avec le contenu de b, en évitant, si possible, la copie (b peut être modifié). Pour les types de classe, il s'agit d'une fonction membre particulière, décrite dans déplacer opérateur d'affectation. (depuis C++11)
Original:
move assignment operator replaces the contents of the object a with the contents of b, avoiding copying if possible (b may be modified). For class types, this is a special member function, described in déplacer opérateur d'affectation. (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.

Pour les non-classe types, de copie et d'affectation mouvement sont indiscernables et sont appelés affectation directe .

' Opérateurs composés d'affectation remplacer le contenu le contenu de l'objet a avec le résultat d'une opération binaire entre la valeur précédente de a et la valeur de b .
Original:
compound assignment operators replace the contents the contents of the object a with the result of a binary operation between the previous value of a and the value of b.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

[modifier] Builtin affectation directe

Pour chaque type de T, les signatures de fonction suivants participent à la résolution de surcharge:

T& operator=(T&, T*);
Tvolatile & operator=(Tvolatile &, T*);

Pour chaque énumération ou un pointeur vers T type de membre, éventuellement volatile qualifié, la signature de la fonction suivante participe à la résolution de surcharge:

T& operator=(T&, T );

Pour chaque paire A1 et A2, où A1 est un type arithmétique (éventuellement qualifié volatile) et A2 est un type arithmétique promotion, la signature de la fonction suivante participe à la résolution de surcharge:

A1& operator=(A1&, A2);

Pour les expressions E1 de toute T type scalaire, les formes suivantes supplémentaires de l'expression d'assignation builtin sont autorisés:

E1 = {}		(depuis C++11)
E1 = {E2}		(depuis C++11)

Remarque: le ci-dessus comprend tous les types de non-classe, sauf les types de référence, les types tableau, types de fonction et l'void type, qui ne sont pas directement imputables .

L'opérateur d'affectation directe s'attend à une lvalue modifiable que son opérande de gauche et retourne une lvalue identifier l'opérande de gauche après modification. Pour les non-classe les types, l'opérande de droite est implicitement convertie première à la cv-Type sans réserve de l'opérande de gauche, puis sa valeur est copiée dans l'objet identifié par l'opérande gauche .

Lorsque l'opérande de gauche est un type référence, l'opérateur d'affectation s'applique à l'objet visé à .

Si la gauche et les opérandes droit identifier les objets qui se chevauchent, le comportement est indéfini (à moins que le chevauchement est exact et le type est le même)

Si l'opérande de droite est un contreventés-init-list

E1 = {} l'expression est équivalente à E1 = T(), où T est le type de E1 .
Original:
the expression E1 = {} is equivalent to E1 = T(), where T is the type of E1.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
E1 = {E2} l'expression est équivalente à E1 = T(E2), où T est le type de E1, sauf que les conversions restrictives implicites sont interdits .
Original:
the expression E1 = {E2} is equivalent to E1 = T(E2), where T is the type of E1, except that narrowing implicit conversions are prohibited.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

Pour les types de classe, cette syntaxe génère un appel à l'opérateur d'affectation avec std::initializer_list comme argument, suivant les règles de liste d'initialisation

[modifier] Exemple

#include <iostream>
int main()
{
    int n = 0;  // not an assignment
    n = 1;      // direct asignment
    std::cout << n << ' ';
    n = {};     // zero-initialization, then assignment
    std::cout << n << ' ';
    n = 'a';    // integral promotion, then assignment
    std::cout << n << ' ';
    n = {'b'};   // explicit cast, then assignment
    std::cout << n << ' ';
    n = 1.0;    // floating-point conversion, then assignment
    std::cout << n << ' ';
//    n = {1.0}; // compiler error (narrowing conversion)
 
    int& r = n;  // not an assignment
    int* p;
 
    r = 2;       // assignment through reference
    std::cout << n << ' ';
    p = &n;      // direct assignment
    p = nullptr; // null-pointer conversion, then assignment 
}

Résultat :

1 0 97 98 1 2

[modifier] Affectation composée intégré

Pour chaque paire A1 et A2, où A1 est un type arithmétique (éventuellement qualifié volatile) et A2 est un type arithmétique promu, les signatures de fonction suivants participent à la résolution de surcharge:

A1& operator*=(A1&, A2);
A1& operator/=(A1&, A2);
A1& operator+=(A1&, A2);
A1& operator-=(A1&, A2);

Pour chaque paire I1 et I2, où I1 est un type intégral (en option volatile qualifié) et I2 est un type de promotion intégrale, les signatures de fonction suivants participent à la résolution de surcharge:

I1& operator%=(I1&, I2);
I1& operator<<=(I1&, I2);
I1& operator>>=(I1&, I2);
I1& operator&=(I1&, I2);
I1& operator^=(I1&, I2);
I1& operator\|=(I1&, I2);

Pour chaque type d'objet T option cv-qualifié, les signatures de fonction suivants participent à la résolution de surcharge:

T& operator+=(T&, std::ptrdiff_t);
T& operator-=(T&, std::ptrdiff_t);
Tvolatile & operator+=(Tvolatile &, std::ptrdiff_t);
Tvolatile & operator-=(Tvolatile &, std::ptrdiff_t);

{{{1}}}

[modifier] Exemple

This section is incomplete
Reason: no example

[modifier] Voir aussi

La priorité des opérateurs

Opérateurs ordinaires
affectation	incrémentation décrémentation	arithmétique	logique	comparaison	accès aux membre	autre
a = b a = rvalue a += b a -= b a *= b a /= b a %= b a &= b a \|= b a ^= b a <<= b a >>= b	++a --a a++ a--	+a -a a + b a - b a * b a / b a % b ~a a & b a \| b a ^ b a << b a >> b	!a a && b a \|\| b	a == b a != b a < b a > b a <= b a >= b	a[b] a &a a->b a.b a->b a.*b	a(...) a, b (type) a ? :
Opérateurs spéciaux
`static_cast` convertit un type dans un autre type compatible `dynamic_cast` convertit une classe de base virtuelle dans une classe dérivée `const_cast` convertit un type dans un type compatible avec des cv-qualifiers différents `reinterpret_cast` convertit un type dans un type incompatibles `new` allocation de la mémoire `delete` libère de la mémoire `sizeof` récupère la taille d'un type `sizeof...` récupère la taille d'un paquet de paramètres (depuis C++11) `typeid` récupère les informations de type d'un type `noexcept` vérifie si une expression peut lancer une exception (depuis C++11) `alignof` récupère les conditions d'alignement d'un type (depuis C++11)

Récupérée de « https://fr.cppreference.com/mwiki/index.php?title=cpp/language/operator_assignment&oldid=48534 »

Catégorie :

Todo no example

Langage
Concepts
Bibliothèque d'utilitaires
Bibliothèque pour les chaînes de caractères
Bibliothèque de conteneurs
Bibliothèque d'algorithmes
Bibliothèque d'itérateurs
Bibliothèque pour le calcul numérique
Bibliothèque pour les entrées/sorties
Bibliothèque pour la régionalisation
Bibliothèque pour les expressions régulières (C++11)
Bibliothèque pour les opérations atomiques (C++11)
Bibliothèque pour les processus légers (threads) (C++11)

T& operator+=(T&, std::ptrdiff_t);
T& operator-=(T&, std::ptrdiff_t);
Tvolatile & operator+=(Tvolatile &, std::ptrdiff_t);
Tvolatile & operator-=(Tvolatile &, std::ptrdiff_t);

cppreference.com

Espaces de noms

Variantes

Affichages

Actions

Assignment operators

Sommaire

[modifier] Explication

[modifier] Builtin affectation directe

[modifier] Exemple

[modifier] Affectation composée intégré

[modifier] Exemple

[modifier] Voir aussi

Navigation

Boîte à outils