Assignment operators

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

Linguagem C + +

Tópicos gerais

Preprocessor
Comentários
Palavras-chave

Tabela ASCII
Seqüências de escape
História do C + +

Controle de fluxo

Declarações execução condicional

if statement

switch statement

Instruções de iteração

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

`while` loop
`do-while` loop

Ir declarações

`continue` statement
`break` statement

`goto` statement
`return` statement

Funções

declaração da função

lambda declaração da função

modelo de função

linha especificador

especificações de exceção (obsoleta)

noexcept especificador (C++11)

Exceções

jogar expressão

bloco try-catch

Namespaces

declaração de namespace

aliases namespace

Tipos

tipos fundamentais
tipos de compostos
tipos de enumeração

tipos de união
tipos de função

decltype specifier (C++11)

Especificadores

cv especificadores

armazenamento duração especificadores

constexpr especificador (C++11)

auto especificador (C++11)

alignas especificador (C++11)

Inicialização

inicialização padrão
inicialização de valor
de zero a inicialização
copiar inicialização
inicialização direta

inicialização agregada
lista de inicialização (C++11)
inicialização constante
inicialização de referência

Literais

literais inteiro
literais de caracteres
literais de ponto flutuante
literais de cadeia

literais booleanos
nullptr (C++11)
definido pelo usuário (C++11)

Expressões

categorias de valor
ordem de avaliação

operadores
precedência do operador

representações alternativas

Utilitários

Tipos

typedef declaration

tipo de alias declaração (C++11)

atributos (C++11)

Conversões

conversões implícitas

const_cast conversion

static_cast conversion

dynamic_cast conversion

reinterpret_cast conversion

Elenco C-estilo e funcional

Alocação de memória

new expression

delete expression

Classes

declaração de classe
`this` pointer
especificadores de acesso

amigo especificador
listas inicializador

Classe propriedades específicas de função

função virtual
substituir especificador (C++11)
final de especificador (C++11)

explícita (C++11)
estática

Funções membro especiais

construtor padrão
copiar construtor
mover construtor (C++11)

copiar atribuição
mover atribuição (C++11)
destruidor

Modelos

modelo de classe

modelo de função

especialização de modelo

pacotes de parâmetros (C++11)

Diversos

Assembly embutido

[edit]

Operadores de atribuição modificar o valor do objeto.

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);
'Notas' Original: Notes The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions. Todos embutida atribuição operadores retornar this, ea maioria das definidas pelo utilizador sobrecargas também retornar this de modo a que os operadores definidos pelo utilizador podem ser usados da mesma maneira como o built-ins. No entanto, numa definida pelo utilizador sobrecarga de operador, de qualquer tipo pode ser utilizado como tipo de retorno (incluindo 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` pode ser de qualquer tipo, incluindo `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.

Índice

[editar] Explicação

' Operador de atribuição de cópia substitui o conteúdo do a objecto com uma cópia dos conteúdos do b (b é não modificada). Para os tipos de classe, esta é uma função de membro especial, descrita no copiar operador de atribuição.
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 copiar operador de atribuição.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

' Atribuição movimento operador substitui o conteúdo do a objecto com o conteúdo de b, evitando, se possível, a cópia (b pode ser modificado). Para os tipos de classe, esta é uma função de membro especial, descrita no mover operador de atribuição. (a partir do 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 mover operador de atribuição. (a partir do C++ 11)
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

Para os não-classe tipos, cópia e atribuição movimento são indistinguíveis e são referidos como atribuição direta.

' Operadores compostos de atribuição substituir o conteúdo dos conteúdos do a objecto com o resultado de uma operação de binário entre o valor anterior de a e o valor de 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.

[editar] Builtin atribuição direta

Para cada tipo de T, as assinaturas de função seguintes participar na resolução de sobrecarga:


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

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

Para cada enumeração ou ponteiro para T tipo de membro, opcionalmente volátil qualificado, a assinatura da função seguinte participa de resolução de sobrecarga:


T& operator=(T&, T );

Para cada par A1 e A2, onde A1 é um tipo de aritmética (opcionalmente volátil qualificado) e A2 é um tipo de aritmética promovido, a assinatura da função seguinte participa de resolução de sobrecarga:


A1& operator=(A1&, A2);

Para expressões E1 de qualquer tipo escalar T, as seguintes formas adicionais de expressão de atribuição builtin são permitidos:


E1 = {}		(a partir do C++ 11)

E1 = {E2}		(a partir do C++ 11)

Nota: o acima inclui todos os tipos não-classe, exceto os tipos de referência, tipos de matriz, tipos de função eo void tipo, que não são diretamente atribuíveis.

O operador de atribuição direta espera um lvalue modificável como seu operando esquerdo e retorna um lvalue identificação do operando à esquerda após a modificação. Para os não-classe tipos, o operando direito é convertidos implicitamente primeiro do tipo CV-incondicional do operando à esquerda, e então o seu valor é copiado para o objeto identificado pelo operando esquerdo.

Quando o operando da esquerda é um tipo de referência, o operador de atribuição se aplica ao objeto refere-to.

Se a esquerda e os operandos certas identificar objetos sobrepostos, o comportamento é indefinido (a menos que a sobreposição é exata eo tipo é o mesmo)

Se o operando direito é um preparei-init-lista

o E1 = {} expressão é equivalente a E1 = T(), onde T é o tipo de 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.
o E1 = {E2} expressão é equivalente a E1 = T(E2), onde T é o tipo de E1, excepto que as conversões de estreitamento implícitas são proibidos.
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.

Para os tipos de classes, esta sintaxe gera uma chamada para o operador de atribuição com std::initializer_list como o argumento, seguindo as regras da lista de inicialização

[editar] Exemplo

#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

[editar] Builtin atribuição composto

Para cada par A1 e A2, onde A1 é um tipo de aritmética (opcionalmente volátil qualificado) e A2 é um tipo de aritmética promovido, as assinaturas de função seguintes participar na resolução de sobrecarga:


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

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

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

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

Para cada par I1 e I2, onde I1 é um tipo integral (opcionalmente volátil qualificado) e I2 é um tipo promovido integral, as assinaturas de função seguintes participar na resolução de sobrecarga:


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

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

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

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

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

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

Para cada T opcionalmente cv qualificado tipo de objeto, as assinaturas de função seguintes participar na resolução de sobrecarga:


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

[editar] Exemplo

[editar] Veja também

Precedência do operador

Common operators
atribuição	incrementǊdecrement	aritmética	lógico	comparação	memberǊaccess	outro
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 um tipo para outro tipo compatível 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 base virtual para class derivados 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 tipo para tipo compatível com diferentes 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 de type incompatíveis 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` aloca 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` desaloca 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` consulta o tamanho de um 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...` consulta o tamanho de um bloco de parâmetros (a partir do C++ 11) Original: `sizeof...` queries the size of a bloco de parâmetros (a partir do 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` consulta o tipo de informação de uma 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` verifica se uma expressão pode lançar uma (a partir do C++ 11) exceção Original: `noexcept` checks if an expression can throw an exception (a partir do 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` consultas exigências de alinhamento de um (a partir do C++ 11) tipo Original: `alignof` queries alignment requirements of a type (a partir do C++ 11) The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions.

Linguagem
Conceitos
Biblioteca de utilitários
Biblioteca cordas
Recipientes biblioteca
Biblioteca algoritmos
Biblioteca iteradores
Biblioteca numéricos
De entrada / saída da biblioteca
Biblioteca localizações
Biblioteca de expressões regulares (C++11)
Biblioteca operações atômica (C++11)
Biblioteca de suporte a discussão (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

Pesquisa

Espaços nominais

Variantes

Vistas

Acções

Assignment operators

Índice

[editar] Explicação

[editar] Builtin atribuição direta

[editar] Exemplo

[editar] Builtin atribuição composto

[editar] Exemplo

[editar] Veja também

Navegação

Ferramentas