Namespaces
Variants

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

From cppreference.net

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

Reemplaza el contenido del contenedor.

Sea traits como std:: allocator_traits < allocator_type > :

1) Operador de asignación de copia. Reemplaza el contenido con una copia del contenido de other .
Si traits :: propagate_on_container_copy_assignment :: value es true , el asignador de * this se reemplaza 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 reutilizarse cuando sea posible. En cualquier caso, los elementos que originalmente pertenecían a * this pueden ser destruidos o reemplazados por asignación de copia elemento por elemento.
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 * this es reemplazado por una copia del de other . Si es false y los asignadores de * this y other no son iguales, * this no puede tomar posesión de la memoria propiedad de other y debe asignar por movimiento cada elemento individualmente, 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 por asignación por movimiento elemento a 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 e ilist .

Excepciones

2)
noexcept especificación:
noexcept ( 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 refieren a 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::forward_list a otro:

Ejecutar este código 
#include <initializer_list>
#include <iostream>
#include <iterator>
#include <forward_list>
void print(const auto comment, const auto& container)
{
    auto size = std::ranges::distance(container);
    std::cout << comment << "{ ";
    for (const auto& element : container)
        std::cout << element << (--size ? ", " : " ");
    std::cout << "}\n";
}
int main()
{
    std::forward_list<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 forward_list
(función miembro pública)
asigna valores al contenedor
(función miembro pública)