Assignment operators

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

Definiciones

Asignación de copia reemplaza los contenidos del objeto a con una copia de los contenidos de b ( b no se modifica). Para tipos de clase, esto se realiza en una función miembro especial, descrita en el operador de asignación de copia .

Para tipos no clase, la asignación por copia y la asignación por movimiento son indistinguibles y se denominan asignación directa .

Asignación compuesta reemplaza el contenido del objeto a con el resultado de una operación binaria entre el valor anterior de a y el valor de b .

Sintaxis del operador de asignación

Las expresiones de asignación tienen la forma

1. ↑ target-expr debe tener mayor precedencia que una expresión de asignación.
2. ↑ new-value no puede ser una expresión de coma, porque su precedencia es menor.

Operador de asignación simple incorporado

Para la asignación simple incorporada, target-expr debe ser un lvalue modificable.

El objeto referenciado por target-expr es modificado reemplazando su valor con el resultado de new-value . Si el objeto referenciado es de un tipo entero T , y el resultado de new-value es del tipo entero con signo/sin signo correspondiente, el valor del objeto es reemplazado con el valor de tipo T con la misma representación de valor del resultado de new-value .

El resultado de una asignación simple incorporada es un lvalue del tipo de target-expr , que hace referencia a target-expr . Si target-expr es un campo de bits , el resultado también es un campo de bits.

Asignación desde una expresión

Si new-value es una expresión, se convierte implícitamente al tipo sin calificadores cv de target-expr . Cuando target-expr es un campo de bits que no puede representar el valor de la expresión, el valor resultante del campo de bits está definido por la implementación.

Si target-expr y new-value identifican objetos que se superponen, el comportamiento es indefinido (a menos que la superposición sea exacta y el tipo sea el mismo).

#include <complex>
std::complex<double> z;
z = {1, 2};  // meaning z.operator=({1, 2})
z += {1, 2}; // meaning z.operator+=({1, 2})
int a, b;
a = b = {1}; // meaning a = b = 1;
a = {1} = b; // syntax error

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

Para cada tipo de enumeración o puntero a miembro T , opcionalmente calificado con volatile, la siguiente firma de función participa en la resolución de sobrecarga:

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

Operador de asignación compuesta incorporado

El comportamiento de cada expresión de asignación compuesta incorporada target-expr op  = new-value es exactamente igual al comportamiento de la expresión target-expr = target-expr op new-value , excepto que target-expr se evalúa solo una vez.

Los requisitos sobre target-expr y new-value de los operadores de asignación simples incorporados también se aplican. Además:

• Para + = y - = , el tipo de target-expr debe ser un tipo aritmético o un puntero a un tipo objeto completamente definido (posiblemente calificado cv).
• Para todos los demás operadores de asignación compuesta, el tipo de target-expr debe ser un tipo aritmético.

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

Para cada par I1 y I2 , donde I1 es un tipo integral (opcionalmente calificado como volatile) y I2 es un tipo integral promovido, las siguientes firmas de función participan en la resolución de sobrecarga:

Para cada tipo de objeto opcionalmente calificado cv T , las siguientes firmas de función participan en la resolución de sobrecarga:

Ejemplo

#include <iostream>
int main()
{
    int n = 0;        // no es una asignación
    n = 1;            // asignación directa
    std::cout << n << ' ';
    n = {};           // inicialización a cero, luego asignación
    std::cout << n << ' ';
    n = 'a';          // promoción entera, luego asignación
    std::cout << n << ' ';
    n = {'b'};        // conversión explícita, luego asignación
    std::cout << n << ' ';
    n = 1.0;          // conversión de punto flotante, luego asignación
    std::cout << n << ' ';
//  n = {1.0};        // error del compilador (conversión restrictiva)
    int& r = n;       // no es una asignación
    r = 2;            // asignación a través de referencia
    std::cout << n << ' ';
    int* p;
    p = &n;           // asignación directa
    p = nullptr;      // conversión a puntero nulo, luego asignación
    std::cout << p << ' ';
    struct { int a; std::string s; } obj;
    obj = {1, "abc"}; // asignación desde una lista de inicialización entre llaves
    std::cout << obj.a << ':' << obj.s << '\n';
}

1 0 97 98 1 2 (nil) 1:abc

Informes de defectos

Los siguientes informes de defectos que modifican el comportamiento se aplicaron retroactivamente a los estándares de C++ publicados anteriormente.

Véase también

Precedencia de operadores

Sobrecarga de operadores