Los operadores de asignación modifican el valor del objeto.

Nombre del operador Sintaxis Sobrecarga capaz Ejemplos de prototipos (para class T)
Definición de clase interna Definición de clase externa
asignación simple a = b sí T& T::operator =(const T2& b); N / A
asignación de adición a += b sí T& T::operator +=(const T2& b); T& operator +=(T& a, const T2& b);
asignación de resta a -= b sí T& T::operator -=(const T2& b); T& operator -=(T& a, const T2& b);
asignación de multiplicación a *= b sí T& T::operator *=(const T2& b); T& operator *=(T& a, const T2& b);
asignación de división a /= b sí T& T::operator /=(const T2& b); T& operator /=(T& a, const T2& b);
asignación de módulo a %= b sí T& T::operator %=(const T2& b); T& operator %=(T& a, const T2& b);
asignación AND bit a bit a &= b sí T& T::operator &=(const T2& b); T& operator &=(T& a, const T2& b);
Asignación OR bit a bit a |= b sí T& T::operator |=(const T2& b); T& operator |=(T& a, const T2& b);
Asignación XOR bit a bit a ^= b sí T& T::operator ^=(const T2& b); T& operator ^=(T& a, const T2& b);
Asignación de desplazamiento a la izquierda bit a bit a <<= b sí T& T::operator <<=(const T2& b); T& operator <<=(T& a, const T2& b);
Asignación de desplazamiento a la derecha bit a bit a >>= b sí T& T::operator >>=(const T2& b); T& operator >>=(T& a, const T2& b);
Notas

  • Todos los operadores de asignación incorporados regresan *this, y la mayoría de las sobrecargas definidas por el usuario también devuelven *this para que los operadores definidos por el usuario se puedan utilizar de la misma manera que los integrados. Sin embargo, en una sobrecarga de operador definida por el usuario, cualquier tipo se puede utilizar como tipo de retorno (incluido void).
  • T2 puede ser de cualquier tipo, incluido T

Explicación

copiar asignación operador reemplaza el contenido del objeto a con una copia del contenido de b (b no se modifica). Para los tipos de clase, esta es una función de miembro especial, descrita en el operador de asignación de copia.

mover asignación operador reemplaza el contenido del objeto a con el contenido de b, evitando copiar si es posible (b puede ser modificado). Para los tipos de clase, esta es una función miembro especial, descrita en el operador de asignación de movimiento. (desde C ++ 11).

Para los tipos que no son de clase, la asignación de copiar y mover son indistinguibles y se denominan asignación directa.

asignación compuesta los operadores reemplazan el contenido del objeto a con el resultado de una operación binaria entre el valor anterior de a y el valor de b.

Asignación directa incorporada

Las expresiones de asignación directa tienen la forma.

lhs=rhs (1)
lhs = (2) (desde C ++ 11)
lhs = rhs (3) (desde C ++ 11)

Para el operador integrado, lhs puede tener cualquier tipo escalar no constante y rhs debe ser implícitamente convertible al tipo de lhs.

El operador de asignación directa espera un lvalue modificable como su operando izquierdo y una expresión rvalue o un lista-inicial-reforzada(desde C ++ 11) como su operando derecho, y devuelve un valor l que identifica el operando izquierdo después de la modificación.

Para los tipos que no son de clase, el operando derecho primero se convierte implícitamente al tipo cv-no calificado del operando izquierdo, y luego su valor se copia en el objeto identificado por el operando izquierdo.

Cuando el operando de la izquierda tiene un tipo de referencia, el operador de asignación modifica el objeto al que se hace referencia.

Si los operandos izquierdo y derecho identifican objetos superpuestos, el comportamiento no está definido (a menos que la superposición sea exacta y el tipo sea el mismo).

Si el operando correcto es un lista-inicial-reforzada.

  • si la expresión E1 tiene tipo escalar,
    • la expresion E1 = es equivalente a E1 = T, dónde T es el tipo de E1.
    • la expresion E1 = E2 es equivalente a E1 = TE2, dónde T es el tipo de E1.
  • si la expresión E1 tiene tipo de clase, la sintaxis E1 = args... genera una llamada al operador de asignación con el lista-inicial-reforzada como argumento, que luego selecciona el operador de asignación apropiado siguiendo las reglas de resolución de sobrecarga. Tenga en cuenta que, si está disponible un operador de asignación sin plantilla de algún tipo que no sea de clase, se prefiere a la asignación de copiar / mover en E1 = porque a no clase es una conversión de identidad, que supera a la conversión definida por el usuario de a un tipo de clase.
(desde C ++ 11)

En resolución de sobrecarga contra operadores definidos por el usuario, para cada tipo T, las siguientes firmas de funciones participan en la resolución de sobrecarga:

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

Para cada enumeración o puntero al tipo de miembro T, opcionalmente calificado para volátiles, la siguiente firma de función participa en la resolución de sobrecarga:

T&operator=(T&, T );

Para cada par A1 y A2, donde A1 es un tipo aritmético (opcionalmente calificado como volátil) y A2 es un tipo aritmético promovido, la siguiente firma de función participa en la resolución de sobrecarga:

A1&operator=(A1&, A2);

Ejemplo

#includeintmain()int n =0;// not an assignment
    n =1;// direct assignment
    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 assignmentint* p;
 
    r =2;// assignment through reference
    std::cout << n <<'n';
    p =&n;// direct assignment
    p =nullptr;// null-pointer conversion, then assignment structint a; std::string s; obj;
    obj =1,"abc";// assignment from a braced-init-list
    std::cout << obj.a <<':'<< obj.s <<'n';

Producción:

109798121:abc

Asignación de compuestos incorporados

Las expresiones de asignación compuestas tienen la forma.

lhsoprhs (1)
lhs op (2) (desde C ++ 11)
lhs op rhs (3) (desde C ++ 11)
op - uno de *=, /=%=, +=-=, <<=, >>=, &=, ^=, |=
lhs - para el operador integrado, lhs puede tener cualquier tipo aritmético, excepto cuando op es += o -=, que también acepta tipos de puntero con las mismas restricciones que + y -
rhs - para el operador integrado, rhs debe ser implícitamente convertible a lhs

El comportamiento de cada expresión de asignación compuesta incorporada E1 op= E2 (donde E1 es una expresión lvalue modificable y E2 es una expresión rvalue o un lista-inicial-reforzada(desde C ++ 11)) es exactamente el mismo que el comportamiento de la expresión E1 = E1 op E2, excepto que la expresión E1 se evalúa solo una vez y que se comporta como una sola operación con respecto a las llamadas a funciones secuenciadas indeterminadamente (por ejemplo, en f(a += b, g()), el + = no se inicia en absoluto o se completa como se ve desde adentro g()).

En la resolución de sobrecarga contra operadores definidos por el usuario, para cada par A1 y A2, donde A1 es un tipo aritmético (opcionalmente calificado como volátil) y A2 es un tipo aritmético promovido, las siguientes firmas de función participan en la resolución de sobrecarga:

A1&operator*=(A1&, A2);
 
A1&operator/=(A1&, A2);
 
A1&operator+=(A1&, A2);
 
A1&operator-=(A1&, A2);

Para cada par I1 e I2, donde I1 es un tipo integral (opcionalmente calificado para volátiles) e I2 es un tipo integral promovido, las siguientes firmas de función participan en la resolución 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 tipo de objeto calificado opcionalmente para cv T, las siguientes firmas de funciones participan en la resolución de sobrecarga:

T*&operator+=(T*&, std::ptrdiff_t);
 
T*&operator-=(T*&, std::ptrdiff_t);
 
T*volatile&operator+=(T*volatile&, std::ptrdiff_t);
 
T*volatile&operator-=(T*volatile&, std::ptrdiff_t);

Ejemplo

Ver también

Precedencia del operador.

Sobrecarga del operador.

Operadores comunes
asignación incremento
decremento		 aritmética lógico comparación miembro
acceso		 otro

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 especiales

static_cast convierte un tipo en otro tipo relacionado
dynamic_cast convierte dentro de las jerarquías de herencia
const_cast agrega o elimina calificadores de cv
reinterpret_cast convierte el tipo en un tipo no relacionado
El elenco de estilo C convierte un tipo en otro mediante una mezcla de static_cast, const_cast, y reinterpret_cast
new crea objetos con una duración de almacenamiento dinámica
delete destruye objetos previamente creados por la nueva expresión y libera el área de memoria obtenida
sizeof consulta el tamaño de un tipo
sizeof... consulta el tamaño de un paquete de parámetros(desde C ++ 11)
typeid consulta la información de tipo de un tipo
noexcept comprueba si una expresión puede lanzar una excepción (desde C ++ 11)
alignof requisitos de alineación de consultas de un tipo (desde C ++ 11).