Namespaces
Variants

std::vector<T,Allocator>:: operator=

From cppreference.net

C++
Containers library
std::vector
Member types
Member functions
Non-member functions
(until C++20) (until C++20) (until C++20) (until C++20) (until C++20)
Deduction guides (C++17)
vector & operator = ( const vector & other ) ;
(1) (constexpr desde C++20)
(2)
vector & operator = ( vector && other ) ;
(desde C++11)
(hasta C++17)
vector & operator = ( vector && other )
noexcept ( /* ver más abajo */ ) ;
(desde C++17)
(constexpr desde C++20)
vector & operator = ( std:: initializer_list < value_type > ilist ) ;
(3) (desde C++11)
(constexpr desde C++20)

Reemplaza el contenido del contenedor.

Sea traits como std:: allocator_traits < allocator_type > :

1) Operador de asignación de copia. Reemplaza los contenidos con una copia de los contenidos de other .

Si traits :: propagate_on_container_copy_assignment :: value es true , el asignador de * this es reemplazado por una copia de other . Si el asignador de * this después de la asignación comparara desigual a su valor anterior, el asignador antiguo se utiliza para desasignar la memoria, luego el nuevo asignador se utiliza para asignarla antes de copiar los elementos. De lo contrario, la memoria propiedad de * this puede ser reutilizada cuando sea posible. En cualquier caso, los elementos originalmente pertenecientes a * this pueden ser destruidos o reemplazados por asignación de copia elemento por elemento.

(desde C++11)
2) Operador de asignación de movimiento. Reemplaza los contenidos con los de other usando semántica de movimiento (es decir, los datos en other son movidos desde other hacia este contenedor). other queda en un estado válido pero no especificado después.
Si traits :: propagate_on_container_move_assignment :: value es true , el asignador de memoria de * this es reemplazado por una copia del de other . Si es false y los asignadores de memoria de * this y other no son iguales, * this no puede tomar posesión de la memoria poseída por other y debe reasignar cada elemento individualmente mediante movimiento, asignando memoria adicional usando su propio asignador según sea necesario. En cualquier caso, todos los elementos que originalmente pertenecían a * this son destruidos o reemplazados mediante reasignación por movimiento elemento por elemento.
3) Reemplaza el contenido con aquel identificado por la lista de inicialización ilist .

Contenidos

Parámetros

other - otro contenedor para usar como fuente de datos
ilist - lista de inicializadores para usar como fuente de datos

Valor de retorno

* this

Complejidad

1) Lineal en el tamaño de * this y other .
2) Lineal en el tamaño de * this a menos que los asignadores no sean iguales y no se propaguen, en cuyo caso lineal en el tamaño de * this y other .
3) Lineal en el tamaño de * this y ilist .

Excepciones

2)
noexcept especificación:
noexcept ( std:: allocator_traits < Allocator > :: propagate_on_container_move_assignment :: value
|| std:: allocator_traits < Allocator > :: is_always_equal :: value )
(desde C++17)

Notas

Después de la asignación de movimiento del contenedor (sobrecarga ( 2 ) ), a menos que la asignación de movimiento elemento por elemento sea forzada por asignadores incompatibles, las referencias, punteros e iteradores (excepto el iterador final) a other permanecen válidos, pero referencian elementos que ahora están en * this . El estándar actual garantiza esto mediante la declaración general en [container.reqmts]/67 , y se está considerando una garantía más directa a través de LWG issue 2321 .

Ejemplo

El siguiente código utiliza operator = para asignar un std::vector a otro:

Ejecutar este código 
#include <initializer_list>
#include <iostream>
#include <iterator>
#include <vector>
void print(const auto comment, const auto& container)
{
    auto size = std::size(container);
    std::cout << comment << "{ ";
    for (const auto& element : container)
        std::cout << element << (--size ? ", " : " ");
    std::cout << "}\n";
}
int main()
{
    std::vector<int> x{1, 2, 3}, y, z;
    const auto w = {4, 5, 6, 7};
    std::cout << "Initially:\n";
    print("x = ", x);
    print("y = ", y);
    print("z = ", z);
    std::cout << "Copy assignment copies data from x to y:\n";
    y = x;
    print("x = ", x);
    print("y = ", y);
    std::cout << "Move assignment moves data from x to z, modifying both x and z:\n";
    z = std::move(x);
    print("x = ", x);
    print("z = ", z);
    std::cout << "Assignment of initializer_list w to z:\n";
    z = w;
    print("w = ", w);
    print("z = ", z);
}

Salida: 

Initially:
x = { 1, 2, 3 }
y = { }
z = { }
Copy assignment copies data from x to y:
x = { 1, 2, 3 }
y = { 1, 2, 3 }
Move assignment moves data from x to z, modifying both x and z:
x = { }
z = { 1, 2, 3 }
Assignment of initializer_list w to z:
w = { 4, 5, 6, 7 }
z = { 4, 5, 6, 7 }

Véase también

construye el vector
(función miembro pública)
asigna valores al contenedor
(función miembro pública)