Assignment operators

Zuweisungsoperatoren modifizieren den Wert des Objekts.

Definitionen

Copy assignment ersetzt die Inhalte des Objekts a mit einer Kopie der Inhalte von b ( b wird nicht modifiziert). Für Klassentypen wird dies in einer speziellen Memberfunktion durchgeführt, beschrieben im copy assignment operator .

Für Nicht-Klassentypen sind Kopier- und Verschiebezuweisung nicht unterscheidbar und werden als direkte Zuweisung bezeichnet.

Zusammengesetzte Zuweisung ersetzt den Inhalt des Objekts a mit dem Ergebnis einer binären Operation zwischen dem vorherigen Wert von a und dem Wert von b .

Zuweisungsoperator-Syntax

Die Zuweisungsausdrücke haben die Form

1. ↑ target-expr muss eine höhere Präzedenz als ein Zuweisungsausdruck haben.
2. ↑ new-value kann kein Komma-Ausdruck sein, da dessen Präzedenz niedriger ist.

Eingebauter einfacher Zuweisungsoperator

Für die eingebaute einfache Zuweisung muss target-expr ein modifizierbarer Lvalue sein.

Das Objekt, auf das durch target-expr verwiesen wird, wird modifiziert, indem sein Wert durch das Ergebnis von new-value ersetzt wird. Wenn das referenzierte Objekt einen Integer-Typ T hat und das Ergebnis von new-value vom entsprechenden vorzeichenbehafteten/vorzeichenlosen Integer-Typ ist, wird der Wert des Objekts durch den Wert vom Typ T mit derselben Wertdarstellung wie das Ergebnis von new-value ersetzt.

Das Ergebnis einer eingebauten einfachen Zuweisung ist ein Lvalue des Typs von target-expr , der sich auf target-expr bezieht. Wenn target-expr ein Bitfeld ist, ist das Ergebnis ebenfalls ein Bitfeld.

Zuweisung aus einem Ausdruck

Wenn new-value ein Ausdruck ist, wird er implizit konvertiert in den cv-unqualifizierten Typ von target-expr . Wenn target-expr ein Bitfeld ist, das den Wert des Ausdrucks nicht darstellen kann, ist der resultierende Wert des Bitfelds implementierungsdefiniert.

Falls target-expr und new-value überlappende Objekte identifizieren, ist das Verhalten undefiniert (es sei denn, die Überlappung ist exakt und der Typ identisch).

#include <complex>
std::complex<double> z;
z = {1, 2};  // meaning z.operator=({1, 2})
z += {1, 2}; // meaning z.operator+=({1, 2})
int a, b;
a = b = {1}; // meaning a = b = 1;
a = {1} = b; // syntax error

Bei Überlagerungsauflösung gegenüber benutzerdefinierten Operatoren nehmen für jeden Typ T die folgenden Funktionssignaturen an der Überlagerungsauflösung teil:

Für jeden Aufzählungs- oder Zeiger-auf-Mitglied-Typ T , optional flüchtig qualifiziert, nimmt die folgende Funktionssignatur an der Überladungsauflösung teil:

Für jedes Paar A1 und A2 , wobei A1 ein arithmetischer Typ (optional volatile-qualifiziert) und A2 ein höhergestufter arithmetischer Typ ist, nimmt die folgende Funktionssignatur an der Überladungsauflösung teil:

Eingebundener zusammengesetzter Zuweisungsoperator

Das Verhalten jedes eingebauten zusammengesetzten Zuweisungsausdrucks target-expr op  = new-value ist genau identisch mit dem Verhalten des Ausdrucks target-expr = target-expr op new-value , mit der Ausnahme, dass target-expr nur einmal ausgewertet wird.

Die Anforderungen an target-expr und new-value der eingebauten einfachen Zuweisungsoperatoren gelten ebenfalls. Darüber hinaus:

• Für + = und - = muss der Typ von target-expr ein arithmetischer Typ oder ein Zeiger auf einen (möglicherweise cv-qualifizierten) vollständig definierten Objekttyp sein.
• Für alle anderen zusammengesetzten Zuweisungsoperatoren muss der Typ von target-expr ein arithmetischer Typ sein.

Bei Überlagerungsauflösung für benutzerdefinierte Operatoren , für jedes Paar A1 und A2 , wobei A1 ein arithmetischer Typ (optional volatile-qualifiziert) und A2 ein höhergestufter arithmetischer Typ ist, nehmen die folgenden Funktionssignaturen an der Überlagerungsauflösung teil:

Für jedes Paar I1 und I2 , wobei I1 ein integraler Typ (optional mit volatile-Qualifizierung) und I2 ein gepromoteter integraler Typ ist, nehmen die folgenden Funktionssignaturen an der Überlagerungsauflösung teil:

Für jeden optional cv-qualifizierten Objekttyp T nehmen die folgenden Funktionssignaturen an der Überladungsauflösung teil:

Beispiel

#include <iostream>
int main()
{
    int n = 0;        // keine Zuweisung
    n = 1;            // direkte Zuweisung
    std::cout << n << ' ';
    n = {};           // Null-Initialisierung, dann Zuweisung
    std::cout << n << ' ';
    n = 'a';          // Ganzzahl-Höherstufung, dann Zuweisung
    std::cout << n << ' ';
    n = {'b'};        // explizite Typumwandlung, dann Zuweisung
    std::cout << n << ' ';
    n = 1.0;          // Gleitkomma-Konvertierung, dann Zuweisung
    std::cout << n << ' ';
//  n = {1.0};        // Compiler-Fehler (verengende Konvertierung)
    int& r = n;       // keine Zuweisung
    r = 2;            // Zuweisung über Referenz
    std::cout << n << ' ';
    int* p;
    p = &n;           // direkte Zuweisung
    p = nullptr;      // Nullzeiger-Konvertierung, dann Zuweisung
    std::cout << p << ' ';
    struct { int a; std::string s; } obj;
    obj = {1, "abc"}; // Zuweisung von einer Initialisierungsliste
    std::cout << obj.a << ':' << obj.s << '\n';
}

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

Fehlerberichte

Die folgenden verhaltensändernden Fehlerberichte wurden rückwirkend auf zuvor veröffentlichte C++-Standards angewendet.

Siehe auch

Operator-Präzedenz

Operatorüberladung