Assignment operators

Les opérateurs d'assignation modifient la valeur de l'objet.

Définitions

Affectation par copie remplace le contenu de l'objet a par une copie du contenu de b ( b n'est pas modifié). Pour les types classe, cette opération est réalisée par une fonction membre spéciale, décrite dans l' opérateur d'affectation par copie .

Pour les types non-classes, l'assignation par copie et l'assignation par déplacement sont indiscernables et sont appelées assignation directe .

Affectation composée remplace le contenu de l'objet a par le résultat d'une opération binaire entre la valeur précédente de a et la valeur de b .

Syntaxe de l'opérateur d'affectation

Les expressions d'assignation ont la forme

1. ↑ target-expr doit avoir une priorité supérieure à celle d'une expression d'affectation.
2. ↑ new-value ne peut pas être une expression virgule, car sa priorité est inférieure.

Opérateur d'assignation simple intégré

Pour l'affectation simple intégrée, target-expr doit être une lvalue modifiable.

L'objet référencé par target-expr est modifié en remplaçant sa valeur par le résultat de new-value . Si l'objet référencé est d'un type entier T , et que le résultat de new-value est du type entier signé/non signé correspondant, la valeur de l'objet est remplacée par la valeur de type T ayant la même représentation de valeur que le résultat de new-value .

Le résultat d'une affectation simple intégrée est une lvalue du type de target-expr , se référant à target-expr . Si target-expr est un champ de bits , le résultat est également un champ de bits.

Affectation à partir d'une expression

Si new-value est une expression, elle est implicitement convertie vers le type non qualifié cv de target-expr . Lorsque target-expr est un champ de bits qui ne peut pas représenter la valeur de l'expression, la valeur résultante du champ de bits est définie par l'implémentation.

Si target-expr et new-value identifient des objets qui se chevauchent, le comportement est indéfini (sauf si le chevauchement est exact et que le type est identique).

#include <complex>
std::complex<double> z;
z = {1, 2};  // signification z.operator=({1, 2})
z += {1, 2}; // signification z.operator+=({1, 2})
int a, b;
a = b = {1}; // signification a = b = 1;
a = {1} = b; // erreur de syntaxe

Dans la résolution de surcharge pour les opérateurs définis par l'utilisateur , pour chaque type T , les signatures de fonction suivantes participent à la résolution de surcharge :

Pour chaque type d'énumération ou pointeur sur membre T , optionnellement qualifié volatile, la signature de fonction suivante participe à la résolution de surcharge :

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

Opérateur d'affectation composée intégré

Le comportement de chaque expression d'affectation composée intégrée target-expr op  = new-value est exactement le même que le comportement de l'expression target-expr = target-expr op new-value , sauf que target-expr n'est évalué qu'une seule fois.

Les exigences concernant target-expr et new-value des opérateurs d'affectation simples intégrés s'appliquent également. De plus :

• Pour + = et - = , le type de target-expr doit être un type arithmétique ou un pointeur vers un type objet complètement défini (éventuellement qualifié cv).
• Pour tous les autres opérateurs d'affectation composés, le type de target-expr doit être un type arithmétique.

Dans la résolution de surcharge pour les opérateurs définis par l'utilisateur , 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 suivantes participent à la résolution de surcharge :

Pour chaque paire I1 et I2 , où I1 est un type intégral (éventuellement qualifié volatile) et I2 est un type intégral promu, les signatures de fonction suivantes participent à la résolution de surcharge :

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

Exemple

#include <iostream>
int main()
{
    int n = 0;        // pas une affectation
    n = 1;            // affectation directe
    std::cout << n << ' ';
    n = {};           // initialisation à zéro, puis affectation
    std::cout << n << ' ';
    n = 'a';          // promotion entière, puis affectation
    std::cout << n << ' ';
    n = {'b'};        // cast explicite, puis affectation
    std::cout << n << ' ';
    n = 1.0;          // conversion en virgule flottante, puis affectation
    std::cout << n << ' ';
//  n = {1.0};        // erreur de compilation (conversion restrictive)
    int& r = n;       // pas une affectation
    r = 2;            // affectation via référence
    std::cout << n << ' ';
    int* p;
    p = &n;           // affectation directe
    p = nullptr;      // conversion en pointeur nul, puis affectation
    std::cout << p << ' ';
    struct { int a; std::string s; } obj;
    obj = {1, "abc"}; // affectation depuis une liste d'initialisation entre accolades
    std::cout << obj.a << ':' << obj.s << '\n';
}

1 0 97 98 1 2 (nil) 1:abc

Rapports de défauts

Les rapports de défauts modifiant le comportement suivants ont été appliqués rétroactivement aux normes C++ précédemment publiées.

Voir aussi

Priorité des opérateurs

Surcharge d'opérateur