Namespaces
Variants

std::flat_set<Key,Compare,KeyContainer>:: operator=

From cppreference.net

C++
Containers library
std::flat_set
Member types
Member functions
Helper classes
Tags
Deduction guides
flat_set & operator = ( const flat_set & other ) ;
(1) (desde C++23)
(declarado implícitamente)
flat_set & operator = ( flat_set && other ) ;
(2) (desde C++23)
(declarado implícitamente)
flat_set & operator = ( std:: initializer_list < key_type > ilist ) ;
(3) (desde C++23)

Reemplaza el contenido del adaptador de contenedor con el contenido del argumento dado.

1) Operador de asignación de copia. Reemplaza el contenido con una copia del contenido de other . Efectivamente llama a c = other. c ; comp = other. comp ; .
2) Operador de asignación de movimiento. Reemplaza el contenido con el de other usando semántica de movimiento. Efectivamente llama a c = std :: move ( other. c ) ; comp = std :: move ( other. comp ) ; .
3) Reemplaza el contenido con aquel identificado por la lista de inicialización ilist .

Contenidos

Parámetros

other - otro adaptador de contenedor que se utilizará como fuente
ilist - lista de inicialización que se utilizará como fuente

Valor de retorno

* this

Complejidad

1,2) Equivalente al del operator = del contenedor subyacente.
3) Lineal en el tamaño de * this y ilist .

Ejemplo

Ejecutar este código 
#include <flat_set>
#include <initializer_list>
#include <print>
int main()
{
    std::flat_set<int> x{1, 2, 3}, y, z;
    const auto w = {4, 5, 6, 7};
    std::println("Inicialmente:");
    std::println("x = {}", x);
    std::println("y = {}", y);
    std::println("z = {}", z);
    y = x; // sobrecarga (1)
    std::println("La asignación por copia copia datos de x a y:");
    std::println("x = {}", x);
    std::println("y = {}", y);
    z = std::move(x); // sobrecarga (2)
    std::println("La asignación por movimiento mueve datos de x a z, modificando tanto x como z:");
    std::println("x = {}", x);
    std::println("z = {}", z);
    z = w; // sobrecarga (3)
    std::println("Asignación de initializer_list w a z:");
    std::println("w = {}", w);
    std::println("z = {}", z);
}

Salida: 

Inicialmente:
x = {1, 2, 3}
y = {}
z = {}
La asignación por copia copia datos de x a y:
x = {1, 2, 3}
y = {1, 2, 3}
La asignación por movimiento mueve datos de x a z, modificando tanto x como z:
x = {}
z = {1, 2, 3}
Asignación de initializer_list w a z:
w = {4, 5, 6, 7}
z = {4, 5, 6, 7}

Véase también

construye el flat_set
(función miembro pública)
reemplaza el contenedor subyacente
(función miembro pública)