Assignment operators

Aus cppreference.com

This page has been machine-translated from the English version of the wiki using Google Translate.

The translation may contain errors and awkward wording. Hover over text to see the original version. You can help to fix errors and improve the translation. For instructions click here.

Click here for the English version of this page

Sprache C++

Allgemeine Themen

Preprocessor
Kommentare
Keywords

ASCII-Tabelle
Escape-Sequenzen
Geschichte von C + +

Flusskontrolle

Bedingte Ausführung Aussagen

if statement

switch statement

Iterationsanweisungen

`for` loop
range-`for` loop (C++11)

`while` loop
`do-while` loop

Gehe Aussagen

`continue` statement
`break` statement

`goto` statement
`return` statement

Funktionen

Funktion Erklärung

Lambda-Funktion Erklärung

Funktions-Template

inline-Spezifizierer

Exception-Spezifikationen (veraltet)

noexcept Spezifizierer (C++11)

Ausnahmen

Werfen Ausdruck

try-catch-Block

Namespaces

Namespace-Deklaration

Namespace Aliase

Types

Grundtypen
zusammengesetzte Typen
Aufzählungstypen

union-Typen
Funktionstypen

decltype specifier (C++11)

Specifiers

cv Planer

Lagerdauer Planer

constexpr Spezifizierer (C++11)

auto Spezifizierer (C++11)

alignas Spezifizierer (C++11)

Initialisierung

Default-Initialisierung
Wert der Initialisierung
Null-Initialisierung
Kopieren Initialisierung
direkte Initialisierung

aggregierten Initialisierung
Liste der Initialisierung (C++11)
konstanten Initialisierung
Referenz-Initialisierung

Literale

Integer-Literale
Zeichenliterale
Fließkomma-Literale
Zeichenfolgenliterale

boolean Literale
nullptr (C++11)
benutzerdefiniert (C++11)

Expressions

Wertkategorien
Reihenfolge der Auswertung

Betreiber
Operatorvorrang

alternative Darstellungen

Utilities

Types

typedef declaration

Typ Aliasdeklaration (C++11)

Attribute (C++11)

Wirft

impliziten Konvertierungen

const_cast conversion

static_cast conversion

dynamic_cast conversion

reinterpret_cast conversion

C-Stil und funktionale Besetzung

Speicherzuweisung

new expression

delete expression

Classes

Klassendeklaration
`this` pointer
Zugriff auf Planer

Freund Spezifizierer
Initialisierer Listen

Class-spezifische Funktion Eigenschaften

virtuelle Funktion
Überschreibungsspezifizierer (C++11)
endgültigen Spezifizierer (C++11)

explizit (C++11)
statisch

Besondere Member-Funktionen

Standardkonstruktor
Copy-Konstruktor
bewegen Konstruktor (C++11)

Kopieren Zuordnung
bewegen Zuordnung (C++11)
Destruktor

Templates

Klassen-Template

Funktions-Template

Template-Spezialisierung

Parameter Packs (C++11)

Verschiedenes

Inline Montage

[edit]

Zuweisungsoperatoren ändern Sie den Wert des Objekts .

Operator name	Syntax	Overloadable	Prototype examples (for class T)
Operator name	Syntax	Overloadable	Inside class definition	Outside class definition
basic assignment	`a = b`	Yes	T& T::operator =(const T2& b);	N/A
move assignment (C++11)	`a = rvalue`	Yes	T& T::operator =(T2&& b);	N/A
addition assignment	`a += b`	Yes	T& T::operator +=(const T2& b);	T& operator +=(T& a, const T2& b);
subtraction assignment	`a -= b`	Yes	T& T::operator -=(const T2& b);	T& operator -=(T& a, const T2& b);
multiplication assignment	`a *= b`	Yes	T& T::operator *=(const T2& b);	T& operator *=(T& a, const T2& b);
division assignment	`a /= b`	Yes	T& T::operator /=(const T2& b);	T& operator /=(T& a, const T2& b);
modulo assignment	`a %= b`	Yes	T& T::operator %=(const T2& b);	T& operator %=(T& a, const T2& b);
bitwise AND assignment	`a &= b`	Yes	T& T::operator &=(const T2& b);	T& operator &=(T& a, const T2& b);
bitwise OR assignment	`a \|= b`	Yes	T& T::operator \|=(const T2& b);	T& operator \|=(T& a, const T2& b);
bitwise XOR assignment	`a ^= b`	Yes	T& T::operator ^=(const T2& b);	T& operator ^=(T& a, const T2& b);
bitwise left shift assignment	`a <<= b`	Yes	T& T::operator <<=(const T2& b);	T& operator <<=(T& a, const T2& b);
bitwise right shift assignment	`a >>= b`	Yes	T& T::operator >>=(const T2& b);	T& operator >>=(T& a, const T2& b);
'Notes' Original: Notes The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions. Alle integrierten Zuweisungsoperatoren zurückzukehren this und am meisten benutzerdefinierten Überlastungen auch this so dass die benutzerdefinierte Operatoren in der gleichen Weise wie die Einbauten verwendet werden kann zurückzukehren. Jedoch in einer benutzerdefinierten Operator Überlast kann jeder Typ als Rückkehr-Typ (einschließlich void) verwendet werden . Original: All built-in assignment operators return this, and most user-defined overloads also return this so that the user-defined operators can be used in the same manner as the built-ins. However, in a user-defined operator overload, any type can be used as return type (including void). The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions. `T2` kann jeder Typ einschließlich `T` sein Original: `T2` can be any type including `T` The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions.

Inhaltsverzeichnis

[Bearbeiten] Erklärung

Zuweisungsoperator Operator ersetzt den Inhalt des Objekts a mit einer Kopie des Inhalts b (b wird nicht modifiziert). Für Klasse-Typen ist dies eine spezielle Elementfunktion, in Kopieren Zuweisungsoperator beschrieben .

' Bewegen Zuordnung Operator ersetzt den Inhalt des Objekts a mit dem Inhalt b unter Vermeidung Kopierens wenn möglich (b kann modifiziert werden). Für Klasse-Typen ist dies eine spezielle Elementfunktion, in bewegen Zuweisungsoperator beschrieben. (seit C++11)
Original:
move assignment operator replaces the contents of the object a with the contents of b, avoiding copying if possible (b may be modified). For class types, this is a special member function, described in bewegen Zuweisungsoperator. (seit C++11)
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

Für Nicht-Klasse-Typen sind Kopieren und Verschieben Zuordnung zu unterscheiden und werden als direkte Zuordnung bezeichnet .

' Verbundzuweisung Betreiber ersetzen den Inhalt der Inhalt des Objekts a mit dem Ergebnis einer binären Operation zwischen dem vorherigen Wert des a und dem Wert des b .
Original:
compound assignment operators replace the contents the contents of the object a with the result of a binary operation between the previous value of a and the value of b.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

[Bearbeiten] Builtin direkte Zuordnung

Für jede Art T, beteiligen die folgende Funktion Signaturen in Überlast-Auflösung:


T& operator=(T&, T*);

Tvolatile & operator=(Tvolatile &, T*);

Für jede Aufzählung oder Zeiger auf Elementtyp T, wahlweise flüchtigen qualifizierte, beteiligt sich die folgende Funktion Signatur in Überlast-Auflösung:


T& operator=(T&, T );

Für jedes Paar A1 und A2, wobei A1 ist ein arithmetischer Typ (optional flüchtigen qualifizierte) und A2 ist ein befördert arithmetischen Typ, beteiligt sich die folgende Funktion Signatur in Überlast-Auflösung:


A1& operator=(A1&, A2);

Für Ausdrücke E1 jeder skalaren Typ T, werden die folgenden zusätzlichen Formen der builtin Zuweisungsausdruck erlaubt:


E1 = {}		(seit C++11)

E1 = {E2}		(seit C++11)

Hinweis: Die oben sind alle Nicht-Klasse-Typen außer Referenztypen, Array-Typen, Funktionstypen und der Art void, die nicht direkt zuordenbaren .

Die direkte Zuordnung Betreiber rechnet mit einem modifizierbaren lvalue als linken Operanden und gibt eine lvalue Identifizierung des linken Operanden nach der Änderung. Für Nicht-Klasse-Typen, der rechte Operand ersten implizit konvertiert der cv-unqualifizierte Typ des linken Operanden und dann wird sein Wert in das Objekt mit der linken Operanden identifiziert kopiert .

Wenn der linke Operand einen Verweistyp ist, gilt die Abtretung Betreiber bezeichnet-to object .

Wenn die linke und die rechte Operanden identifizieren überlappenden Objekten, ist das Verhalten undefiniert (es sei denn, die Überlappung genau ist und die Art ist das gleiche)

Wenn der rechte Operand ist ein verspannt-init-Liste

der Ausdruck E1 = {} entspricht E1 = T(), wo T die Art der E1 ist .
Original:
the expression E1 = {} is equivalent to E1 = T(), where T is the type of E1.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
der Ausdruck E1 = {E2} entspricht E1 = T(E2), wo T ist die Art der E1, außer dass Verengen impliziten Konvertierungen verboten sind .
Original:
the expression E1 = {E2} is equivalent to E1 = T(E2), where T is the type of E1, except that narrowing implicit conversions are prohibited.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

Für Klasse-Typen generiert diese Syntax einen Aufruf an die Zuweisungsoperator mit std::initializer_list als Argument, nach den Regeln der list-Initialisierung

[Bearbeiten] Beispiel

#include <iostream>
int main()
{
    int n = 0;  // not an assignment
    n = 1;      // direct asignment
    std::cout << n << ' ';
    n = {};     // zero-initialization, then assignment
    std::cout << n << ' ';
    n = 'a';    // integral promotion, then assignment
    std::cout << n << ' ';
    n = {'b'};   // explicit cast, then assignment
    std::cout << n << ' ';
    n = 1.0;    // floating-point conversion, then assignment
    std::cout << n << ' ';
//    n = {1.0}; // compiler error (narrowing conversion)
 
    int& r = n;  // not an assignment
    int* p;
 
    r = 2;       // assignment through reference
    std::cout << n << ' ';
    p = &n;      // direct assignment
    p = nullptr; // null-pointer conversion, then assignment 
}

Output:

1 0 97 98 1 2

[Bearbeiten] Builtin Verbindung Abtretung an

Für jedes Paar A1 und A2, wobei A1 ist ein arithmetischer Typ (optional flüchtigen qualifizierte) und A2 ist ein befördert arithmetischen Typ, beteiligen die folgende Funktion Signaturen in Überlast-Auflösung:


A1& operator*=(A1&, A2);

A1& operator/=(A1&, A2);

A1& operator+=(A1&, A2);

A1& operator-=(A1&, A2);

Für jedes Paar I1 und I2, wobei I1 ist ein integraler Typ (optional flüchtigen qualifizierte) und I2 ist ein befördert integraler Typ, die folgende Funktion Signaturen in Überladungsauflösung teilnehmen:


I1& operator%=(I1&, I2);

I1& operator<<=(I1&, I2);

I1& operator>>=(I1&, I2);

I1& operator&=(I1&, I2);

I1& operator^=(I1&, I2);

I1& operator\|=(I1&, I2);

Für jedes wahlweise cv qualifizierte Objekttyp T, die folgende Funktion Signaturen in Überladungsauflösung teilnehmen:


T& operator+=(T&, std::ptrdiff_t);

T& operator-=(T&, std::ptrdiff_t);

Tvolatile & operator+=(Tvolatile &, std::ptrdiff_t);

Tvolatile & operator-=(Tvolatile &, std::ptrdiff_t);

{{{1}}}

[Bearbeiten] Beispiel

This section is incomplete
Reason: no example

[Bearbeiten] Siehe auch

Operator Vorrang

Common operators
Zuweisungen	incrementǊdecrement	Arithmetik	logisch	Vergleich	memberǊaccess	andererseits
a = b a = rvalue a += b a -= b a *= b a /= b a %= b a &= b a \|= b a ^= b a <<= b a >>= b	++a --a a++ a--	+a -a a + b a - b a * b a / b a % b ~a a & b a \| b a ^ b a << b a >> b	!a a && b a \|\| b	a == b a != b a < b a > b a <= b a >= b	a[b] a &a a->b a.b a->b a.*b	a(...) a, b (type) a ? :
Special operators
`static_cast` wandelt einem Typ in einen anderen kompatiblen Typ Original: `static_cast` converts one type to another compatible type The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions. `dynamic_cast` wandelt virtuellen Basisklasse abgeleitet class Original: `dynamic_cast` converts virtual base class to derived class The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions. `const_cast` wandelt Typ kompatiblen Typ mit unterschiedlichen cv qualifiers Original: `const_cast` converts type to compatible type with different cv qualifiers The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions. `reinterpret_cast` wandelt Typ inkompatibel type Original: `reinterpret_cast` converts type to incompatible type The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions. `new` ordnet memory Original: `new` allocates memory The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions. `delete` freigibt memory Original: `delete` deallocates memory The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions. `sizeof` fragt die Größe eines type Original: `sizeof` queries the size of a type The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions. `sizeof...` fragt die Größe eines Parameter Pack (seit C++11) Original: `sizeof...` queries the size of a Parameter Pack (seit C++11) The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions. `typeid` fragt die Typinformationen eines type Original: `typeid` queries the type information of a type The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions. `noexcept` prüft, ob ein Ausdruck eine Ausnahme (seit C++11) werfen kann Original: `noexcept` checks if an expression can throw an exception (seit C++11) The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions. `alignof` Abfragen Ausrichtungsanforderungen eines Typs (seit C++11) Original: `alignof` queries alignment requirements of a type (seit C++11) The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions.

Von „https://de.cppreference.com/mwiki/index.php?title=cpp/language/operator_assignment&oldid=27097“

Kategorie:

Todo no example

Sprache
Concepts
Utilities-Bibliothek
Strings Bibliothek
Container-Bibliothek
Algorithmen-Bibliothek
Iteratoren Bibliothek
Numerik-Bibliothek
Input / Output-Bibliothek
Lokalisierungen Bibliothek
Reguläre Ausdrücke Bibliothek (C++11)
Atomare Operationen Bibliothek (C++11)
Thread Support-Bibliothek (C++11)


T& operator+=(T&, std::ptrdiff_t);

T& operator-=(T&, std::ptrdiff_t);

Tvolatile & operator+=(Tvolatile &, std::ptrdiff_t);

Tvolatile & operator-=(Tvolatile &, std::ptrdiff_t);

cppreference.com

Namensräume

Varianten

Ansichten

Aktionen

Assignment operators

Inhaltsverzeichnis

[Bearbeiten] Erklärung

[Bearbeiten] Builtin direkte Zuordnung

[Bearbeiten] Beispiel

[Bearbeiten] Builtin Verbindung Abtretung an

[Bearbeiten] Beispiel

[Bearbeiten] Siehe auch

Navigation

Werkzeuge