Assignment operators

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

Linguaggio C + +

Temi generali

Preprocessore
Commenti
Parole chiave

Tabella ASCII
Sequenze di escape
La storia del C + +

Controllo del flusso

Dichiarazioni esecuzione condizionale

if statement

switch statement

Iterazione dichiarazioni

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

`while` loop
`do-while` loop

Vai dichiarazioni

`continue` statement
`break` statement

`goto` statement
`return` statement

Funzioni

dichiarazione di funzione

lambda funzione dichiarazione

funzione di modello

specificatore inline

eccezioni specifiche (deprecato)

noexcept specificatore (C++11)

Eccezioni

tiro espressione

blocco try-catch

Spazi dei nomi

namespace dichiarazione

alias dello spazio dei nomi

Tipi

tipi fondamentali
composti tipi
enumerazione tipi

sindacali tipi
tipi di funzione

decltype specifier (C++11)

Specifiers

cv specificatori

Durata di stoccaggio specificatori

constexpr specificatore (C++11)

specificatore auto (C++11)

alignas specificatore (C++11)

Inizializzazione

predefinito di inizializzazione
valore di inizializzazione
inizializzazione a zero
copiare inizializzazione
inizializzazione diretta

inizializzazioni di aggregazione
elenco di inizializzazione (C++11)
inizializzazione delle costanti
riferimento inizializzazione

Letterali

letterali interi
caratteri letterali
virgola mobile letterali
stringhe letterali

letterali booleani
nullptr (C++11)
definito dall'utente (C++11)

Espressioni

valore categorie
ordine di valutazione

operatori
precedenza degli operatori

rappresentazioni alternative

Utilities

Tipi

typedef declaration

Tipo alias dichiarazione (C++11)

attributi (C++11)

Lancia

conversioni implicite

const_cast conversion

static_cast conversion

dynamic_cast conversion

reinterpret_cast conversion

Fusione C-stile e funzionale

Occupazione della memoria

new expression

delete expression

Classi

classe di dichiarazione
`this` pointer
specificatori di accesso

amico specificatore
liste di inizializzazione

Specifiche per una classe di funzioni proprietà

funzione virtuale
ignorare specificatore (C++11)
identificatore finale (C++11)

esplicito (C++11)
statico

Funzioni membro speciali

costruttore di default
costruttore di copia
spostare costruttore (C++11)

copiare assegnazione
spostare l'assegnazione (C++11)
distruttore

Modelli

classe template

funzione di modello

modello di specializzazione

parametri confezioni (C++11)

Varie

Montaggio in linea

[edit]

Operatori di assegnazione modificare il valore dell'oggetto.

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.

Indice

[modifica] 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.

' 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.

[modifica] Builtin assegnazione diretta

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


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:


T& operator=(T&, T );

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:


A1& operator=(A1&, A2);

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


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.

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.

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

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

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

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

[modifica] 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:

1 0 97 98 1 2

[modifica] 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:


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:


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:


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

[modifica] Esempio

This section is incomplete
Reason: no example

[modifica] 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.

Estratto da "https://it.cppreference.com/mwiki/index.php?title=cpp/language/operator_assignment&oldid=25969"

Categoria:

Todo no example

Linguaggio
Concetti
Libreria di Utilità
Stringhe
Contenitori
Algoritmi
Iteratori
Libreria matematca
Input/output
Localizzazione
Espressioni regolari (C++11)
Operazioni atomicche (C++11)
Multithreading (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

Namespace

Varianti

Visite

Azioni

Assignment operators

Indice

[modifica] Spiegazione

[modifica] Builtin assegnazione diretta

[modifica] Esempio

[modifica] Builtin assegnazione composta

[modifica] Esempio

[modifica] Vedi anche

Navigazione

Strumenti