Assignment operators - cppreference.com

Da cppreference.com.

Questa pagina è stata tradotta in modo automatico dalla versione in ineglese della wiki usando Google Translate.

La traduzione potrebbe contenere errori e termini strani. Muovi il puntatore sopra al testo per vedere la versione originale. Puoi aiutarci a correggere gli gli errori. Per ulteriori istruzioni clicca qui.

Click here for the English version of this page

Operatori di assegnazione modificare il valore dell'oggetto.

Original:

Assignment operators modify the value of the object.

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

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);`
'Nota' Original: Notes The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions. Tutti incorporato assegnazione operatori restituiscono `this`, e la maggior parte definiti dall'utente sovraccarichi anche restituire `this` modo che gli operatori definiti dall'utente possono essere utilizzati nello stesso modo come il built-in. Tuttavia, in una definita dall'utente overload dell'operatore, qualsiasi tipo può essere utilizzato come tipo di ritorno (compresi `void`). 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` può essere qualsiasi tipo comprendente `T` 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.

Spiegazione

Copia' assegnazione operatore sostituisce il contenuto del a oggetto con una copia del contenuto di b (b non viene modificato). Per i tipi di classe, questa è una funzione membro speciale, descritto in copiare operatore di assegnazione.

Original:

copy assignment operator replaces the contents of the object a with a copy of the contents of b (b is no modified). For class types, this is a special member function, described in copiare operatore di assegnazione.

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

Mossa' assegnazione operatore sostituisce il contenuto del a oggetto con il contenuto di b, evitando la copia se possibile (b può essere modificato). Per i tipi di classe, questa è una funzione membro speciale, descritto in spostare operatore di assegnazione. (dal 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 spostare operatore di assegnazione. (dal C++11)

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

Per i non-classe tipi, copia e spostamento di assegnazione sono indistinguibili e sono indicati come l'assegnazione diretta.

Original:

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

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

' Operatori composti di assegnazione sostituire il contenuto dei contenuti del a oggetto con il risultato di un'operazione binaria tra il valore precedente a e il valore di 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.

Builtin assegnazione diretta

Per ogni tipo di T, le firme delle funzioni seguenti partecipare risoluzione di sovraccarico:

Original:

For every type T, the following function signatures participate in overload resolution:

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.


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

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

Per ogni enumerazione o puntatore a un membro del tipo T, facoltativamente volatili-qualificata, la firma seguente funzione partecipa risoluzione di sovraccarico:

Original:

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

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

Per ogni coppia di A1 e A2, dove A1 è un tipo aritmetico (opzionalmente volatili-qualificata) e A2 è un tipo aritmetico promosso, la firma seguente funzione partecipa risoluzione di sovraccarico:

Original:

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:

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

Per le espressioni E1 di qualsiasi T tipo scalare, le seguenti forme supplementari di espressione di assegnazione builtin sono consentiti:

Original:

For expressions E1 of any scalar type T, the following additional forms of the builtin assignment expression are allowed:

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.


`E1 = {}`		(dal C++11)

`E1 = {E2}`		(dal C++11)

Nota: quanto sopra non include tutti i tipi ad eccezione di classe tipi di riferimento, i tipi di array, tipi di funzioni e il void tipo, che non sono direttamente imputabili.

Original:

Note: the above includes all non-class types except reference types, array types, function types, and the type void, which are not directly assignable.

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

L'operatore di assegnazione diretta si aspetta un lvalue modificabile come i suoi operando sinistro e restituisce un lvalue che identifica l'operando di sinistra dopo la modifica. Per i non-classe tipi, l'operando di destra è conversione implicita primo al cv-non qualificato tipo di operando di sinistra, e quindi il suo valore viene copiato dentro l'oggetto identificato da operando di sinistra.

Original:

The direct assignment operator expects a modifiable lvalue as its left operand and returns an lvalue identifying the left operand after modification. For non-class types, the right operand is first conversione implicita to the cv-unqualified type of the left operand, and then its value is copied into the object identified by left operand.

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

Quando l'operando di sinistra è un tipo di riferimento, l'operatore di assegnazione si applica al-di cui all'oggetto.

Original:

When the left operand is a reference type, the assignment operator applies to the referred-to object.

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

Se la sinistra e gli operandi giusti identificare oggetti sovrapposti, il comportamento è indefinito (a meno che la sovrapposizione è esatta e il tipo è lo stesso)

Original:

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)

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

Se l'operando di destra è un rinforzato-init-list

Original:

If the right operand is a braced-init-list

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

la E1 = {} espressione è equivalente a E1 = T(), dove T è il tipo di E1.
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.
il E1 = {E2} espressione è equivalente a E1 = T(E2), dove T è il tipo di E1, salvo che conversioni implicite sono vietate.
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.

Per i tipi di classe, questa sintassi genera una chiamata l'operatore di assegnamento con std::initializer_list come argomento, seguendo le regole di list-inizializzazione

Original:

For class types, this syntax generates a call to the assignment operator with std::initializer_list as the argument, following the rules of list-inizializzazione

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

Esempio

#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:

Builtin assegnazione composta

Per ogni coppia di A1 e A2, dove A1 è un tipo aritmetico (opzionalmente volatili-qualificata) e A2 è un tipo aritmetico promosso, le firme delle funzioni seguenti partecipare risoluzione di sovraccarico:

Original:

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:

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.


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

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

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

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

Per ogni coppia di I1 e I2, dove I1 è un tipo integrale (opzionalmente volatili-qualificata) e I2 è un tipo di promozione integrale, le firme delle funzioni seguenti partecipare risoluzione di sovraccarico:

Original:

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:

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.


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

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

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

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

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

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

Per ogni oggetto T opzionalmente cv tipo qualificato, le firme delle funzioni seguenti partecipare risoluzione di sovraccarico:

Original:

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

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.


`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}}}

Original:

{{{2}}}

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

Esempio

Vedi anche

Precedenza degli operatori

Common operators
assegnazione	incrementǊdecrement	aritmetica	logico	confronto	memberǊaccess	altra
`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` converte un tipo a un altro tipo compatibile 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` converte classe virtuale di base per class derivato 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` converte il tipo di tipo compatibile con diversi 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` converte tipo type incompatibile 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` alloca 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` dealloca 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` interroga la dimensione di un 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...` interroga le dimensioni di un parametro confezione (dal C++11) Original: `sizeof...` queries the size of a parametro confezione (dal 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` interroga le informazioni sul tipo di una 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` controlla se un'espressione può lanciare una (dal C++11) un'eccezione Original: `noexcept` checks if an expression can throw an exception (dal 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` query requisiti di allineamento di un (dal C++11) tipo Original: `alignof` queries alignment requirements of a type (dal C++11) The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions.

Categorie:


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

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

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

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