Opérateurs d’assignation

Article
03/09/2024

Syntaxe

expression assignment-operator expression

assignment-operator : l'un des éléments suivants :
= *= /= %= += -= <<= >>= &= ^= |=

Notes

Les opérateurs d'assignation stockent une valeur dans l'objet spécifié par l'opérande de gauche. Il existe deux types d’opérations d’assignation :

l’assignation simple, dans laquelle la valeur du deuxième opérande est stockée dans l’objet spécifié par le premier opérande.
l’assignation composée, dans laquelle une opération arithmétique, décalée ou au niveau du bit est effectuée avant de stocker le résultat.

Tous les opérateurs d'assignation décrits dans le tableau suivant, à l'exception de l'opérateur =, sont des opérateurs d'assignation composée.

Table des opérateurs d'assignation

Opérateur	Signification
`=`	Enregistre la valeur du deuxième opérande dans l’objet spécifié par le premier opérande (assignation simple).
*`=`**	Multiplie la valeur du premier opérande par la valeur du deuxième opérande ; enregistre le résultat dans l’objet spécifié par le premier opérande.
`/=`	Divise la valeur du premier opérande par la valeur du deuxième opérande ; enregistre le résultat dans l’objet spécifié par le premier opérande.
`%=`	Accepte le module du premier opérande spécifié par la valeur du deuxième opérande ; enregistre le résultat dans l’objet spécifié par le premier opérande.
`+=`	Ajoute la valeur du deuxième opérande à la valeur du premier opérande ; enregistre le résultat dans l’objet spécifié par le premier opérande.
`-=`	Soustrait la valeur du deuxième opérande de la valeur du premier opérande ; enregistre le résultat dans l’objet spécifié par le premier opérande.
`<<=`	Déplace la valeur du premier opérande à gauche du nombre de bits spécifiés par la valeur du deuxième opérande ; enregistre le résultat dans l’objet spécifié par le premier opérande.
`>>=`	Déplace la valeur du premier opérande à droite du nombre de bits spécifiés par la valeur du deuxième opérande ; enregistre le résultat dans l'objet spécifié par le premier opérande.
`&=`	Obtient l'opérateur de bits AND du premier et du deuxième opérandes ; enregistre le résultat dans l'objet spécifié par le premier opérande.
`^=`	Obtient l'opérateur de bits OR exclusif du premier et du deuxième opérandes ; enregistre le résultat dans l'objet spécifié par le premier opérande.
`\|=`	Obtient l’opérateur de bits OR inclusif du premier et du deuxième opérandes ; enregistre le résultat dans l’objet spécifié par le premier opérande.

Mots clés des opérateurs

Trois des opérateurs d'assignation composée ont des équivalents de mots clés. Il s’agit de :

Opérateur	Équivalent
`&=`	`and_eq`
`\|=`	`or_eq`
`^=`	`xor_eq`

C++ spécifie ces mots clés d’opérateur en tant qu’autres orthographes pour les opérateurs d’assignation composée. En C, l’orthographe alternative est fournie en tant que macros dans l’en-tête <iso646.h>. En C++, les orthographes alternatives sont des mots clés. L’utilisation de <iso646.h> ou de l’équivalent C++ <ciso646> est déconseillée. Dans Microsoft C++, l’option de compilateur /permissive- ou /Za est nécessaire pour activer l’orthographe alternative.

Exemple

// expre_Assignment_Operators.cpp
// compile with: /EHsc
// Demonstrate assignment operators
#include <iostream>
using namespace std;
int main() {
   int a = 3, b = 6, c = 10, d = 0xAAAA, e = 0x5555;

   a += b;      // a is 9
   b %= a;      // b is 6
   c >>= 1;      // c is 5
   d |= e;      // Bitwise--d is 0xFFFF

   cout  << "a = 3, b = 6, c = 10, d = 0xAAAA, e = 0x5555" << endl
         << "a += b yields " << a << endl
         << "b %= a yields " << b << endl
         << "c >>= 1 yields " << c << endl
         << "d |= e yields " << hex << d << endl;
}

Assignation simple

L’opérateur d’assignation simple (=) entraîne le stockage de la valeur du second opérande dans l’objet spécifié par le premier opérande. Si les deux objets sont de type arithmétique, l’opérande droit est converti en type de l’opérande gauche avant le stockage de la valeur.

Les objets des types const et volatile peuvent être assignés à des valeurs l-value de types qui ne sont que volatile, ou qui ne sont pas const ou volatile.

L’assignation à des objets de type de classe (types struct, union et class) est effectuée par une fonction nommée operator=. Le comportement par défaut de cette fonction d’opérateur consiste à effectuer une assignation de copie par membre des membres de données non statiques de l’objet et aux classes de base directes. Toutefois, ce comportement peut être modifié à l’aide d’opérateurs surchargés. Pour plus d’informations, consultez Surcharge d’opérateur. Les types de classes peuvent également avoir des opérateurs d’assignation de copie et d’assignation de déplacement. Pour plus d’informations, consultez Constructeurs de copie et opérateurs d’assignation de copie, ainsi que Constructeurs de déplacement et opérateurs d’assignation de déplacement.

Un objet de toute classe clairement dérivée d'une classe de base donnée peut être assigné à un objet de la classe de base. L'inverse n'est pas vrai, car il existe une conversion implicite de la classe dérivée vers la classe de base, mais pas de la classe de base vers la classe dérivée. Par exemple :

// expre_SimpleAssignment.cpp
// compile with: /EHsc
#include <iostream>
using namespace std;
class ABase
{
public:
    ABase() { cout << "constructing ABase\n"; }
};

class ADerived : public ABase
{
public:
    ADerived() { cout << "constructing ADerived\n"; }
};

int main()
{
    ABase aBase;
    ADerived aDerived;

    aBase = aDerived; // OK
    aDerived = aBase; // C2679
}

Les assignations aux types référence se comportent comme si l'assignation était effectuée à l'objet auquel la référence pointe.

Pour les objets de type classe, l'assignation est différente de l'initialisation. Pour illustrer les différences entre l'assignation et l'initialisation, prenez le code

UserType1 A;
UserType2 B = A;

Le code précédent illustre un initialiseur ; il appelle le constructeur de UserType2 qui accepte un argument de type UserType1. Étant donné le code

UserType1 A;
UserType2 B;

B = A;

l'instruction d'assignation

B = A;

peut avoir l'un des effets suivants :

Appelez la fonction operator= pour UserType2, le operator= fourni dispose d’un argument UserType1.
Appelez la fonction de conversion explicite UserType1::operator UserType2, si une telle fonction existe.
Appelez un constructeur UserType2::UserType2, si un tel constructeur existe, qui accepte un argument UserType1 et copie le résultat.

Assignation composée

Les opérateurs d’assignation composée sont affichés dans la table des opérateurs d’assignation. Ces opérateurs ont la forme e1op= e2, où e1 est une valeur l-value nonconst modifiable et e2 est :

un type arithmétique
un pointeur, si op est + ou -
un type pour lequel il existe une surcharge de operator *op*= correspondante pour le type de e1

Le formulaire e1op= e2 intégré se comporte comme e1=e1ope2, mais e1 n’est évalué qu’une seule fois.

L'assignation composée en type énuméré génère un message d'erreur. Si l’opérande de gauche est de type pointeur, l’opérande de droite doit être de type pointeur ou doit être une expression constante qui correspond à 0. Si l’opérande de gauche est de type intégral, l’opérande de droite ne doit pas être de type pointeur.

Résultat des opérateurs d'assignation intégrés

Les opérateurs d’assignation intégrés retournent la valeur de l’objet spécifiée par l’opérande gauche après l’assignation (et l’opération arithmétique/logique dans le cas d’opérateurs d’assignation composée). Le type résultant est le type de l’opérande gauche. Le résultat d'une expression d'assignation est toujours une l-value. Ces opérateurs ont une associativité de droite à gauche. L’opérande gauche doit être une l-value modifiable.

En ANSI C, le résultat d'une expression d'assignation n'est pas une valeur l-value. Cela signifie que l’expression C++ (a += b) += c légale n’est pas autorisée en C.

Voir aussi

Expressions avec des opérateurs binaires
Opérateurs intégrés, priorité et associativité C++
Opérateurs d'assignation C