Namespaces
Variants

std::flat_map<Key,T,Compare,KeyContainer,MappedContainer>:: operator=

From cppreference.net

C++
Containers library
std::flat_map
Member types
Member functions
Non-member functions
Helper classes
Tags
Deduction guides
flat_map & operator = ( const flat_map & other ) ;
(1) (depuis C++23)
(déclaré implicitement)
flat_map & operator = ( flat_map && other ) ;
(2) (depuis C++23)
(déclaré implicitement)
flat_map & operator = ( std:: initializer_list < value_type > ilist ) ;
(3) (depuis C++23)

Remplace le contenu de l'adaptateur de conteneur par le contenu de l'argument donné.

1) Opérateur d'affectation par copie. Remplace le contenu par une copie du contenu de other . Appelle effectivement c = other. c ; comp = other. comp ; .
2) Opérateur d'affectation par déplacement. Remplace le contenu par celui de other en utilisant la sémantique de déplacement. Effectue effectivement l'appel c = std :: move ( other. c ) ; comp = std :: move ( other. comp ) ; .
3) Remplace le contenu par celui identifié par la liste d'initialisation ilist .

Table des matières

Paramètres

other - un autre adaptateur de conteneur à utiliser comme source
ilist - une liste d'initialisation à utiliser comme source

Valeur de retour

* this

Complexité

1,2) Équivalent à celui de operator = du conteneur sous-jacent.
3) Linéaire dans la taille de * this et ilist .

Exemple

Exécuter ce code 
#include <flat_map>
#include <initializer_list>
#include <print>
#include <utility>
int main()
{
    std::flat_map<int, int> x{{1, 1}, {2, 2}, {3, 3}}, y, z;
    const auto w = {std::pair<const int, int>{4, 4}, {5, 5}, {6, 6}, {7, 7}};
    std::println("Initialement :");
    std::println("x = {}", x);
    std::println("y = {}", y);
    std::println("z = {}", z);
    y = x; // surcharge (1)
    std::println("L'assignation par copie copie les données de x vers y :");
    std::println("x = {}", x);
    std::println("y = {}", y);
    z = std::move(x); // surcharge (2)
    std::println("L'assignation par déplacement déplace les données de x vers z, modifiant à la fois x et z :");
    std::println("x = {}", x);
    std::println("z = {}", z);
    z = w; // surcharge (3)
    std::println("Assignation de l'initializer_list w à z :");
    std::println("w = {}", w);
    std::println("z = {}", z);
}

Sortie : 

Initialement :
x = {1: 1, 2: 2, 3: 3}
y = {}
z = {}
L'assignation par copie copie les données de x vers y :
x = {1: 1, 2: 2, 3: 3}
y = {1: 1, 2: 2, 3: 3}
L'assignation par déplacement déplace les données de x vers z, modifiant à la fois x et z :
x = {}
z = {1: 1, 2: 2, 3: 3}
Assignation de l'initializer_list w à z :
w = {4: 4, 5: 5, 6: 6, 7: 7}
z = {4: 4, 5: 5, 6: 6, 7: 7}

Voir aussi

construit le flat_map
(fonction membre publique)
remplace les conteneurs sous-jacents
(fonction membre publique)