Assignment operators

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.

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. (desde 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. (desde 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.

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 = {}`		(desde C++11)

`E1 = {E2}`		(desde 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

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 
}

Saída:

1 0 97 98 1 2

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

Exemplo

Veja também

Precedência do operador

Suporte ao Compilador
Freestanding and hosted
Linguagem
Headers da Biblioteca Standard
Requerimentos nomeados
Feature test macros (C++20)
Biblioteca de suporte de língua
Biblioteca de conceitos (C++20)
Biblioteca de diagnósticos
Biblioteca de utilitários em geral
Biblioteca de strings
Biblioteca de containers
Ranges library (C++20)
Biblioteca de iteradores
Biblioteca de algorítmos
Biblioteca numérica
Biblioteca de localizações
Biblioteca de input/output
Biblioteca de sistema de arquivo (C++17)
Biblioteca de expressões regulares (C++11)
Biblioteca de operações atômicas (C++11)
Biblioteca de suporte de thread (C++11)
Especificações Técnicas
Índice de symbolos
Bibliotecas externas


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

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

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

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

Operadores comuns
assinamento	incremento descremento	aritmético	lógico	comparação	acesso de membro	outros
`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 ? :`
Operadores Especiais
`static_cast` converte um tipo a um outro tipo relacionado `dynamic_cast` converte dentro de hierarquias de herança `const_cast` adiciona ou remove qualificadores cv `reinterpret_cast` converte tipo a tipo não relacionado C-style cast converte um tipo a um outro por uma mistura de `static_cast`, `const_cast`, e `reinterpret_cast` `new` cria objetos com duração de armazenamento dinâmico `delete` destrói objetos anteriormente criads pela expressão new e libera área de memória obtida `sizeof` pesquisa o tamanho de um tipo `sizeof...` pesquisa o tamanho de um pacote de parâmetro (desde C++11) `typeid` pesquisa a informação de tipo de um tipo `noexcept` checa se uma expressão pode lançar uma exceção (desde C++11) `alignof` pesquisa requerimentos de alinhamento de um tipo (desde C++11)

Sunbelt Computer Software

PL/B Language Development and Support

cppreference.com

Procurar

Espaços nominais

Variantes

Visualizações

Ações

Assignment operators

Índice

Explicação

Builtin atribuição direta

Exemplo

Builtin atribuição composto

Exemplo

Veja também

Navegação

Ferramentas