Assignment operators

Zuweisungs- und kombinierte Zuweisungsoperatoren sind binäre Operatoren, die die Variable zu ihrer linken Seite unter Verwendung des Werts zu ihrer rechten Seite modifizieren.

Einfache Zuweisung

Die einfachen Zuweisungsoperatorausdrücke haben die Form

wo

Die Zuweisung führt eine implizite Konvertierung vom Wert von rhs zum Typ von lhs durch und ersetzt dann den Wert in dem durch lhs bezeichneten Objekt durch den konvertierten Wert von rhs .

Die Zuweisung gibt auch denselben Wert zurück, der in lhs gespeichert wurde (sodass Ausdrücke wie a = b = c möglich sind). Die Wertkategorie des Zuweisungsoperators ist Non-Lvalue (sodass Ausdrücke wie ( a = b ) = c ungültig sind).

rhs und lhs müssen eines der folgenden Kriterien erfüllen:

• sowohl lhs als auch rhs haben kompatible struct - oder union -Typ, oder..
• rhs muss implizit konvertierbar zu lhs sein, was impliziert

• sowohl lhs als auch rhs haben arithmetische Typen , in welchem Fall lhs möglicherweise volatile -qualifiziert sein kann oder atomic (seit C11)
• sowohl lhs als auch rhs haben Zeiger auf kompatible (Qualifizierer ignorierende) Typen, oder einer der Zeiger ist ein Zeiger auf void, und die Konvertierung würde keine Qualifizierer zum Zieltyp hinzufügen. lhs kann volatile oder restrict (seit C99) -qualifiziert sein oder atomic (seit C11) .
• lhs ist ein (möglicherweise qualifizierter oder atomic (seit C11) ) Zeiger und rhs ist eine Nullzeiger-Konstante wie NULL oder ein nullptr_t -Wert (seit C23)

Hinweise

Wenn rhs und lhs sich im Speicher überlappen (z.B. wenn sie Mitglieder derselben Union sind), ist das Verhalten undefiniert, es sei denn, die Überlappung ist exakt und die Typen sind kompatibel .

Obwohl Arrays nicht zuweisbar sind, ist ein in einer Struktur verpacktes Array einem anderen Objekt desselben (oder kompatiblen) Strukturtyps zuweisbar.

Die Nebenwirkung der Aktualisierung von lhs ist sequenziert nach den Wertberechnungen, aber nicht den Nebenwirkungen von lhs und rhs selbst, und die Auswertungen der Operanden sind wie üblich unsequenziert relativ zueinander (daher sind Ausdrücke wie i = ++ i ; undefiniert)

Zuweisung entfernt zusätzlichen Bereich und Präzision von Gleitkomma-Ausdrücken (siehe FLT_EVAL_METHOD ).

In C++ sind Zuweisungsoperatoren Lvalue-Ausdrücke, nicht so in C.

#include <stdio.h>
int main(void)
{
    // Ganzzahlen
    int i = 1, j = 2, k = 3; // Initialisierung, keine Zuweisung
    i = j = k;   // Werte von i und j sind nun 3
//  (i = j) = k; // Fehler: Lvalue erforderlich
    printf("%d %d %d\n", i, j, k);
    // Zeiger
    const char c = 'A'; // Initialisierung; keine Zuweisung
    const char *p = &c;  // Initialisierung; keine Zuweisung
    const char **cpp = &p; // Initialisierung; keine Zuweisung
//  cpp = &p;   // Fehler: char** ist nicht konvertierbar zu const char**
    *cpp = &c;  // OK, char* ist konvertierbar zu const char*
    printf("%c \n", **cpp);
    cpp = 0;    // OK, Nullzeigerkonstante ist zu jedem Zeiger konvertierbar
    // Arrays
    int arr1[2] = {1,2}, arr2[2] = {3, 4};
//  arr1 = arr2; // Fehler: Kann keinem Array zuweisen
    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: Kann in Strukturen eingebettete Arrays zuweisen
    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

Zusammengesetzte Zuweisung

Die zusammengesetzten Zuweisungsoperatorausdrücke haben die Form

wo

Der Ausdruck lhs @= rhs ist exakt dasselbe wie lhs = lhs @ ( rhs ) , mit der Ausnahme, dass lhs nur einmal ausgewertet wird.

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

Referenzen

Siehe auch

Operatorpräzedenz

Siehe auch