Assignment operators

Les opérateurs d'assignation et d'assignation composée sont des opérateurs binaires qui modifient la variable à leur gauche en utilisant la valeur à leur droite.

Affectation simple

Les expressions d'opérateur d'assignation simple ont la forme

où

L'assignation effectue une conversion implicite de la valeur de rhs vers le type de lhs puis remplace la valeur dans l'objet désigné par lhs par la valeur convertie de rhs .

L'assignation retourne également la même valeur que celle stockée dans lhs (de sorte que des expressions telles que a = b = c sont possibles). La catégorie de valeur de l'opérateur d'assignation est non-lvalue (de sorte que des expressions telles que ( a = b ) = c sont invalides).

rhs et lhs doivent satisfaire l'une des conditions suivantes :

• à la fois lhs et rhs ont un type compatible de struct ou union , ou..
• rhs doit être implicitement convertible en lhs , ce qui implique

• les deux lhs et rhs ont des types arithmétiques , auquel cas lhs peut être volatile -qualifié ou atomic (depuis C11)
• les deux lhs et rhs ont des pointeurs vers des types compatibles (en ignorant les qualificateurs), ou l'un des pointeurs est un pointeur vers void, et la conversion n'ajouterait pas de qualificateurs au type pointé. lhs peut être volatile ou restrict (depuis C99) -qualifié ou atomic (depuis C11) .
• lhs est un pointeur (éventuellement qualifié ou atomic (depuis C11) ) et rhs est une constante de pointeur nul telle que NULL ou une valeur nullptr_t (depuis C23)

Notes

Si rhs et lhs se chevauchent en mémoire (par exemple, ils sont membres de la même union), le comportement est indéfini sauf si le chevauchement est exact et que les types sont compatibles .

Bien que les tableaux ne soient pas assignables, un tableau encapsulé dans une structure est assignable à un autre objet du même type de structure (ou d'un type compatible).

L'effet secondaire de la mise à jour de lhs est séquencé après les calculs de valeur, mais pas les effets secondaires de lhs et rhs eux-mêmes, et les évaluations des opérandes sont, comme d'habitude, non séquencées les unes par rapport aux autres (ainsi les expressions telles que i = ++ i ; sont indéfinies)

L'assignation supprime la plage et la précision supplémentaires des expressions à virgule flottante (voir FLT_EVAL_METHOD ).

En C++, les opérateurs d'assignation sont des expressions lvalue, ce qui n'est pas le cas en C.

#include <stdio.h>
int main(void)
{
    // entiers
    int i = 1, j = 2, k = 3; // initialisation, pas assignation
    i = j = k;   // les valeurs de i et j sont maintenant 3
//  (i = j) = k; // Erreur : lvalue requis
    printf("%d %d %d\n", i, j, k);
    // pointeurs
    const char c = 'A'; // initialisation; pas assignation
    const char *p = &c;  // initialisation; pas assignation
    const char **cpp = &p; // initialisation; pas assignation
//  cpp = &p;   // Erreur : char** n'est pas convertible en const char**
    *cpp = &c;  // OK, char* est convertible en const char*
    printf("%c \n", **cpp);
    cpp = 0;    // OK, la constante de pointeur nul est convertible en tout pointeur
    // tableaux
    int arr1[2] = {1,2}, arr2[2] = {3, 4};
//  arr1 = arr2; // Erreur : impossible d'assigner à un tableau
    printf("arr1[0]=%d arr1[1]=%d arr2[0]=%d arr2[1]=%d\n",
            arr1[0],   arr1[1],   arr2[0],   arr2[1]);
    struct { int arr[2]; } sam1 = { {5, 6} }, sam2 = { {7, 8} };
    sam1 = sam2; // OK : peut assigner des tableaux encapsulés dans des structures
    printf("%d %d \n", sam1.arr[0], sam1.arr[1]);
}

3 3 3
A
arr1[0]=1 arr1[1]=2 arr2[0]=3 arr2[1]=4
7 8

Affectation composée

Les expressions d'opérateur d'affectation composée ont la forme

où

L'expression lhs @= rhs est exactement la même que lhs = lhs @ ( rhs ) , sauf que lhs n'est évalué qu'une seule fois.

T1* addr = &lhs;
T2 val = rhs;
T1 old = *addr;
T1 new;
do { new = old @ val } while (!atomic_compare_exchange_strong(addr, &old, new);

#include <stdio.h>
int main(void)
{
    int x = 10; 
    int hundred = 100; 
    int ten = 10; 
    int fifty = 50; 
    printf("%d %d %d %d\n", x, hundred, ten, fifty);
    hundred *= x; 
    ten     /= x; 
    fifty   %= x; 
    printf("%d %d %d %d\n", x, hundred, ten, fifty);
    return 0;
}

10 100 10 50
10 1000 1 0

Références

Voir aussi

Priorité des opérateurs

Voir aussi