Assignment Operator Deutsch

Assignment operators modify the value of the object.

Operator name Syntax Over​load​able Prototype examples (for class T)
Inside class definition Outside class definition
simple assignment Yes T& T::operator=(const T2& b);N/A
addition assignment Yes T& T::operator+=(const T2& b);T& operator +=(T& a, const T2& b);
subtraction assignment Yes T& T::operator-=(const T2& b);T& operator -=(T& a, const T2& b);
multiplication assignment Yes T& T::operator*=(const T2& b);T& operator *=(T& a, const T2& b);
division assignment Yes T& T::operator/=(const T2& b);T& operator /=(T& a, const T2& b);
modulo assignment Yes T& T::operator%=(const T2& b);T& operator %=(T& a, const T2& b);
bitwise AND assignment Yes T& T::operator&=(const T2& b);T& operator &=(T& a, const T2& b);
bitwise OR assignment Yes T& T::operator|=(const T2& b);T& operator |=(T& a, const T2& b);
bitwise XOR assignment Yes T& T::operator^=(const T2& b);T& operator ^=(T& a, const T2& b);
bitwise left shift assignment Yes T& T::operator<<=(const T2& b);T& operator <<=(T& a, const T2& b);
bitwise right shift assignment Yes T& T::operator>>=(const T2& b);T& operator >>=(T& a, const T2& b);
Notes
  • 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).
  • can be any type including

[edit]Explanation

copy assignment operator replaces the contents of the object with a copy of the contents of ( is not modified). For class types, this is a special member function, described in copy assignment operator.

move assignment operator replaces the contents of the object with the contents of , avoiding copying if possible ( may be modified). For class types, this is a special member function, described in move assignment operator. (since C++11)

For non-class types, copy and move assignment are indistinguishable and are referred to as direct assignment.

compound assignment operators replace the contents of the object with the result of a binary operation between the previous value of and the value of .

[edit]Builtin direct assignment

The direct assignment expressions have the form

lhsrhs (1)
lhs = {} (2) (since C++11)
lhs = {rhs} (3) (since C++11)

For the built-in operator, lhs may have any non-const scalar type and rhs must be implicitly convertible to the type of lhs.

The direct assignment operator expects a modifiable lvalue as its left operand and an rvalue expression or a braced-init-list(since C++11) as its right operand, and returns an lvalue identifying the left operand after modification.

For non-class types, the right operand is first implicitly converted to the cv-unqualified type of the left operand, and then its value is copied into the object identified by left operand.

When the left operand has reference type, the assignment operator modifies the referred-to object.

If the left and the right operands identify overlapping objects, the behavior is undefined (unless the overlap is exact and the type is the same)

If the right operand is a braced-init-list

  • if the expression has scalar type,
  • the expression E1 ={} is equivalent to E1 = T{}, where is the type of .
  • the expression E1 ={E2} is equivalent to E1 = T{E2}, where is the type of .
  • if the expression has class type, the syntax E1 ={args...} generates a call to the assignment operator with the braced-init-list as the argument, which then selects the appropriate assignment operator following the rules of overload resolution. Note that, if a non-template assignment operator from some non-class type is available, it is preferred over the copy/move assignment in because to non-class is an identity conversion, which outranks the user-defined conversion from to a class type.
(since C++11)

In overload resolution against user-defined operators, for every type , the following function signatures participate in overload resolution:

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

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

For every enumeration or pointer to member type , optionally volatile-qualified, the following function signature participates in overload resolution:

T& operator=(T&, T );

For every pair A1 and A2, where A1 is an arithmetic type (optionally volatile-qualified) and A2 is a promoted arithmetic type, the following function signature participates in overload resolution:

A1& operator=(A1&, A2);

[edit]Example

Run this code

Output:

#include <iostream>int main(){int n =0;// not an assignment n =1;// direct assignmentstd::cout<< n <<' '; n ={};// zero-initialization, then assignmentstd::cout<< n <<' '; n ='a';// integral promotion, then assignmentstd::cout<< n <<' '; n ={'b'};// explicit cast, then assignmentstd::cout<< n <<' '; n =1.0;// floating-point conversion, then assignmentstd::cout<< n <<' ';// n = {1.0}; // compiler error (narrowing conversion)   int& r = n;// not an assignmentint* p;   r =2;// assignment through referencestd::cout<< n <<'\n'; p =&n;// direct assignment p = nullptr;// null-pointer conversion, then assignment   struct{int a;std::string s;} obj; obj ={1, "abc"};// assignment from a braced-init-liststd::cout<< obj.a<<':'<< obj.s<<'\n';}

[edit]Builtin compound assignment

The compound assignment expressions have the form

lhsoprhs (1)
lhs op {} (2) (since C++11)
lhs op {rhs} (3) (since C++11)
op - one of *=, /=%=, +=-=, <<=, >>=, &=, ^=, |=
lhs - for the built-in operator, lhs may have any arithmetic type, except when op is += or -=, which also accept pointer types with the same restrictions as + and -
rhs - for the built-in operator, rhs must be implicitly convertible to lhs

The behavior of every builtin compound-assignment expression E1 op= E2 (where E1 is a modifiable lvalue expression and E2 is an rvalue expression or a braced-init-list(since C++11)) is exactly the same as the behavior of the expression E1 = E1 op E2, except that the expression is evaluated only once and that it behaves as a single operation with respect to indeterminately-sequenced function calls (e.g. in f(a += b, g()), the += is either not started at all or is completed as seen from inside g()).

In overload resolution against user-defined operators, for every pair A1 and A2, where A1 is an arithmetic type (optionally volatile-qualified) and A2 is a promoted arithmetic type, the following function signatures participate in overload resolution:

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

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

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

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

For every pair I1 and I2, where I1 is an integral type (optionally volatile-qualified) and I2 is a promoted integral type, the following function signatures participate in overload resolution:

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

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

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

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

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

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

For every optionally cv-qualified object type , the following function signatures participate in overload resolution:

[edit]Example

[edit]See also

Operator precedence

Operator overloading

Common operators
assignment increment
decrement
arithmetic logical comparison member
access
other

a = b
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[b]
*a
&a
a->b
a.b
a->*b
a.*b

a(...)
a, b
?:

Special operators

converts one type to another related type
converts within inheritance hierarchies
adds or removes cv qualifiers
converts type to unrelated type
C-style cast converts one type to another by a mix of , , and
creates objects with dynamic storage duration
destructs objects previously created by the new expression and releases obtained memory area
queries the size of a type
queries the size of a parameter pack(since C++11)
queries the type information of a type
checks if an expression can throw an exception (since C++11)
queries alignment requirements of a type (since C++11)

Zuweisungsoperatoren

Der einfachste Zuweisungsoperator ist "=". Wahrscheinlich kommt man als erstes auf die Idee, ihn mit "ist gleich" zu bezeichnen. Das ist falsch. In Wirklichkeit bedeutet er, dass dem linken Operanden der Wert des Ausdrucks auf der rechten Seite zugewiesen wird (man müsste ihn also mit "wird gesetzt auf den Wert von" übersetzen).

Der Wert eines Zuweisungs-Ausdruckes ist der zugewiesene Wert. D.h. der Wert des Ausdruckes "$a = 3" ist 3. Das erlaubt es, einige raffinierte Dinge anzustellen:

Zusätzlich zu dem oben vorgestellten Zuweisungsoperator "=" gibt es "kombinierte Operatoren" für alle binären, arithmetischen und String-Operatoren, die es erlauben, den Wert einer Variablen in einem Ausdruck zu benutzen, und dieser anschließend das Ergebnis des Ausdrucks als neuen Wert zuzuweisen. Zum Beispiel:

Man beachte, dass die Zuweisung nur den Wert der Ursprungsvariable der neuen Variable zuweist (Zuweisung als Wert, sie "kopiert"), weshalb sich Änderungen an der einen Variablen nicht auf die andere auswirken werden. Das kann wichtig sein, wenn man ein großes Array o. ä. in einer Schleife kopieren muss. Beginnend mit PHP 4 wird 'assignement by reference' (Zuweisung als Verweis), mit Hilfe der Schreibweise $var =&$othervar; unterstützt , das funktioniert jedoch nicht in PHP 3. 'Assignement by reference' bedeutet, dass beide Variablen nach der Zuweisung die selben Daten repräsentieren und nichts kopiert wird. Um mehr über Referenzen zu lernen, lesen Sie bitte den Abschnitt Referenzen erklärt.

straz at mac dot nospam dot com

14 years ago

Peter, Moscow

7 years ago

Robert Schneider

3 years ago

Hayley Watson

10 years ago

ma dot bx dot ar at gamil dot com

3 years ago

asc at putc dot de

2 years ago

Hayley Watson

10 years ago

bradlis7 at bradlis7 dot com

12 years ago

haubertj at alfredstate dot edu

6 years ago

Comments

Leave a Reply

Your email address will not be published. Required fields are marked *