Operadores de atribuição

Sintaxe

expression assignment-operator expression

assignment-operator: um de
 = *= /= %= += -= <<= >>= &= ^= |=

Comentários

Os operadores de atribuição armazenam um valor no objeto especificado pelo operando esquerdo. Há dois tipos de operações de atribuição:

• atribuição simples, em que o valor do segundo operando é armazenado no objeto especificado pelo primeiro operando.

• atribuição composta, em que uma operação aritmética, de deslocamento ou bit a bit é executada antes de armazenar o resultado.

Todos os operadores de atribuição na tabela a seguir, exceto o operador =, são operadores de atribuição composta.

Tabela de operadores de atribuição

Operador	Significado
=	Armazena o valor do segundo operando no objeto especificado pelo primeiro operando (atribuição simples).
*=	Multiplica o valor do primeiro operando pelo valor do segundo operando; armazena o resultado no objeto especificado pelo primeiro operando.
/=	Divide o valor do primeiro operando pelo valor do segundo operando; armazena o resultado no objeto especificado pelo primeiro operando.
%=	Obtém o módulo do primeiro operando especificado pelo valor do segundo operando; armazena o resultado no objeto especificado pelo primeiro operando.
+=	Soma o valor do segundo operando ao valor do primeiro operando; armazena o resultado no objeto especificado pelo primeiro operando.
-=	Subtrai o valor do segundo operando do valor do primeiro operando; armazena o resultado no objeto especificado pelo primeiro operando.
<<=	Alterna o valor do primeiro operando à esquerda do número de bits especificado pelo valor do segundo operando; armazena o resultado no objeto especificado pelo primeiro operando.
>>=	Alterna o valor do primeiro operando à direita do número de bits especificado pelo valor do segundo operando; armazena o resultado no objeto especificado pelo primeiro operando.
&=	Obtém o bit a bit AND do primeiro e do segundo operandos; armazena o resultado no objeto especificado pelo primeiro operando.
^=	Obtém o bit a bit exclusivo OR do primeiro e do segundo operandos; armazena o resultado no objeto especificado pelo primeiro operando.
|=	Obtém o bit a bit inclusivo OR do primeiro e do segundo operandos; armazena o resultado no objeto especificado pelo primeiro operando.

Palavras-chave de operador

Três dos operadores de atribuição composta têm equivalentes de palavra-chave. São elas:

Operador	Equivalente
&=	and_eq
|=	or_eq
^=	xor_eq

C++ especifica essas palavras-chave do operador como ortografias alternativas para os operadores de atribuição composta. Em C, as ortografias alternativas são fornecidas como uma macro no cabeçalho <iso646.h>. Em C++, as ortografias alternativas são palavras-chaves; o uso de <iso646.h> ou do equivalente em C++ <ciso646> foi preterido. No Microsoft C++, a opção do compilador /permissive- ou /Za é necessária para habilitar a ortografia alternativa.

Exemplo

// expre_Assignment_Operators.cpp
// compile with: /EHsc
// Demonstrate assignment operators
#include <iostream>
using namespace std;
int main() {
   int a = 3, b = 6, c = 10, d = 0xAAAA, e = 0x5555;

   a += b;      // a is 9
   b %= a;      // b is 6
   c >>= 1;      // c is 5
   d |= e;      // Bitwise--d is 0xFFFF

   cout  << "a = 3, b = 6, c = 10, d = 0xAAAA, e = 0x5555" << endl
         << "a += b yields " << a << endl
         << "b %= a yields " << b << endl
         << "c >>= 1 yields " << c << endl
         << "d |= e yields " << hex << d << endl;
}

Atribuição simples

O operador de atribuição simples (=) faz com que o valor do segundo operando seja armazenado no objeto especificado pelo primeiro operando. Se os dois objetos forem de tipos aritméticos, o operando da direita será convertido no tipo da esquerda, antes de armazenar o valor.

Os objetos dos tipos const e volatile podem ser atribuídos a l-values de tipos que são apenas volatile, ou que não são const ou volatile.

A atribuição a objetos do tipo de classe (tipos struct, union e class) é realizada por uma função nomeada como operator=. O comportamento padrão dessa função de operador é executar uma atribuição de cópia por membro dos membros de dados não estáticos do objeto e classes base diretas; no entanto, esse comportamento pode ser modificado usando operadores sobrecarregados. Para obter mais informações, consulte Sobrecarga de operador. Os tipos de classe também podem ter operadores de atribuição de cópia e de movimentação de atribuição. Para obter mais informações, consulte Copiar construtores e operadores de atribuição de cópia e operadores de atribuição de movimentação e construtores de movimentação.

Um objeto de qualquer classe derivada exclusiva de uma classe base pode ser atribuída a um objeto da classe base. O contrário não é verdadeiro porque há uma conversão implícita da classe derivada para a classe base, mas não da classe base para a classe derivada. Por exemplo:

// expre_SimpleAssignment.cpp
// compile with: /EHsc
#include <iostream>
using namespace std;
class ABase
{
public:
    ABase() { cout << "constructing ABase\n"; }
};

class ADerived : public ABase
{
public:
    ADerived() { cout << "constructing ADerived\n"; }
};

int main()
{
    ABase aBase;
    ADerived aDerived;

    aBase = aDerived; // OK
    aDerived = aBase; // C2679
}

As atribuições para tipos de referência se comportam como se uma atribuição foi feita ao objeto ao qual a referência aponta.

Para objetos de tipo classe, a atribuição é diferente de inicialização. Para ilustrar como a atribuição e a inicialização podem ser diferentes, considere o código

UserType1 A;
UserType2 B = A;

O código anterior mostra um inicializador; ele chama o construtor de UserType2 que usa um argumento do tipo UserType1. Dado o código

UserType1 A;
UserType2 B;

B = A;

a instrução de atribuição

B = A;

pode ter um dos seguintes efeitos

• Chama a função operator= para UserType2, contanto que operator= seja fornecido com um argumento UserType1.

• Chama a função de conversão explícita UserType1::operator UserType2, se essa função existir.

• Chamar um construtor UserType2::UserType2, desde que essa construtor exista, que usa um argumento UserType1 e copia o resultado.

Atribuição composta

Os operadores de atribuição composta são mostrados na Tabela de operadores de atribuição. Esses operadores têm a forma e1op= e2, onde e1 é um l-value não const modificável e e2 é:

• um tipo aritmético

• um ponteiro, se op for + ou -

• um tipo para o qual existe uma sobrecarga correspondente operator *op*= para o tipo de e1

A forma interna e1op= e2 se comporta como e1=e1ope2, mas e1 é avaliado somente uma vez.

A atribuição composta para um tipo enumerado gera uma mensagem de erro. Se o operando esquerdo for de um tipo ponteiro, o operando direito deverá ser do tipo ponteiro ou ser uma expressão constante avaliada como 0. Se o operando esquerdo for do tipo integral, o operando direito não deverá ser de um tipo ponteiro.

Resultado dos operadores de atribuição internos

Os operadores de atribuição internos retornam o valor do objeto especificado pelo operando esquerdo após a atribuição (e a operação aritmética/lógica no caso de operadores de atribuição composta). O tipo resultante é o tipo do operando esquerdo. O resultado de uma expressão de atribuição é sempre um l-value. Esses operadores binários possuem associatividade da direita para a esquerda. O operando esquerdo deve ser um l-value modificável.

Em ANSI C, o resultado de uma expressão de atribuição não é um l-value. Isso significa que a expressão legal C++ (a += b) += c não é permitida em C.

Confira também

Expressões com operadores binários
Operadores internos, precedência e associatividade no C++
Operadores de atribuição C