Namespaces
Variants

std::flat_map<Key,T,Compare,KeyContainer,MappedContainer>:: insert

From cppreference.net
C++
Containers library
std::flat_map
Member types
Member functions
Non-member functions
Helper classes
Tags
Deduction guides
std:: pair < iterator, bool > insert ( const value_type & value ) ;
(1) (depuis C++23)
std:: pair < iterator, bool > insert ( value_type && value ) ;
(2) (depuis C++23)
iterator insert ( const_iterator pos, const value_type & value ) ;
(3) (depuis C++23)
iterator insert ( const_iterator pos, value_type && value ) ;
(4) (depuis C++23)
template < class P >
std:: pair < iterator, bool > insert ( P && x ) ;
(5) (depuis C++23)
template < class P >
iterator insert ( const_iterator pos, P && x ) ;
(6) (depuis C++23)
template < class InputIt >
void insert ( InputIt first, InputIt last ) ;
(7) (depuis C++23)
template < class InputIt >
void insert ( std:: sorted_unique_t , InputIt first, InputIt last ) ;
(8) (depuis C++23)
void insert ( std:: initializer_list < key_type > ilist ) ;
(9) (depuis C++23)
void insert ( std:: sorted_unique_t s, std:: initializer_list < key_type > ilist ) ;
(10) (depuis C++23)

Insère un ou plusieurs éléments dans le conteneur, si celui-ci ne contient pas déjà un élément avec une clé équivalente.

1) Insère value . Équivalent à return emplace ( value ) ; .
2) Insère value . Équivalent à return emplace ( std :: move ( value ) ) ; .
3) Insère value à la position la plus proche possible de celle située juste avant pos . Équivalent à return emplace_hint ( pos, value ) ; .
4) Insère value à la position aussi proche que possible de la position juste avant pos . Équivalent à return emplace_hint ( pos, std :: move ( value ) ) ; .
5) Si * this contient déjà un élément qui compare de manière transparente équivalent à x , ne fait rien. Sinon, insère x dans * this comme par emplace ( std:: forward < P > ( x ) ) ; . Cette surcharge participe à la résolution de surcharge seulement si std:: is_constructible_v < std:: pair < key_type, mapped_type > , P > est true .
6) Si * this contient déjà un élément qui se compare de manière transparente équivalent à x , ne fait rien. Sinon, insère x dans * this à la position aussi proche que possible de la position juste avant pos . Équivalent à return emplace_hint ( pos, std:: forward < P > ( x ) ) ; . Cette surcharge participe à la résolution de surcharge seulement si std:: is_constructible_v < std:: pair < key_type, mapped_type > , P > est true .
7) Insère les éléments de l'intervalle [ first , last ) comme si les opérations suivantes étaient effectuées séquentiellement :
  1. Ajoute les éléments à c comme par
    for ( ; first ! = last ; ++ first )
    {
    value_type value = * first ;
    c. keys . insert ( c. keys . end ( ) , std :: move ( value. first ) ) ;
    c. values . insert ( c. values . end ( ) , std :: move ( value. second ) ) ;
    }
  2. Trie l'intervalle des éléments nouvellement insérés par rapport à value_comp .
  3. Fusionne l'intervalle trié résultant et l'intervalle trié des éléments préexistants en un seul intervalle trié.
  4. Efface les éléments dupliqués comme par :
    auto zv = std :: views:: zip ( c. keys , c. values ) ;
    auto it = ranges:: unique ( zv, key_equiv ( compare ) ) . begin ( ) ;
    auto dist = std:: distance ( zv. begin ( ) , it ) ;
    c. keys . erase ( c. keys . begin ( ) + dist, c. keys . end ( ) ) ;
    c. values . erase ( c. values . begin ( ) + dist, c. values . end ( ) ) ;
Peut allouer de la mémoire pendant l'opération de fusion en place.
Si plusieurs éléments dans la plage ont des clés qui sont équivalentes par comparaison, il n'est pas spécifié quel élément est inséré (en attente de LWG2844 ).
8) Insère les éléments de l'intervalle [ first , last ) comme si les opérations suivantes étaient effectuées séquentiellement :
  1. Ajoute des éléments à c comme suit :
    for ( ; first ! = last ; ++ first )
    {
    value_type value = * first ;
    c. keys . insert ( c. keys . end ( ) , std :: move ( value. first ) ) ;
    c. values . insert ( c. values . end ( ) , std :: move ( value. second ) ) ;
    }
  2. Fusionne la plage triée des éléments nouvellement ajoutés et la plage triée des éléments préexistants en une seule plage triée.
  3. Efface les éléments en double comme suit :
    auto zv = std :: views:: zip ( c. keys , c. values ) ;
    auto it = ranges:: unique ( zv, key_equiv ( compare ) ) . begin ( ) ;
    auto dist = std:: distance ( zv. begin ( ) , it ) ;
    c. keys . erase ( c. keys . begin ( ) + dist, c. keys . end ( ) ) ;
    c. values . erase ( c. values . begin ( ) + dist, c. values . end ( ) ) ;
Peut allouer de la mémoire pendant l'opération de fusion en place.
Si plusieurs éléments dans la plage ont des clés qui sont équivalentes par comparaison, il n'est pas spécifié quel élément est inséré (en attente de LWG2844 ).
9) Insère les éléments de la liste d'initialisation ilist . Équivalent à insert ( ilist. begin ( ) , ilist. end ( ) ) ; .
Si plusieurs éléments dans la plage ont des clés qui sont équivalentes par comparaison, il n'est pas spécifié quel élément est inséré (en attente de LWG2844 ).
10) Insère les éléments de la liste d'initialisation ilist . Équivalent à insert ( s, ilist. begin ( ) , ilist. end ( ) ) ; .
Si plusieurs éléments dans la plage ont des clés qui sont équivalentes par comparaison, il n'est pas spécifié quel élément est inséré (en attente de LWG2844 ).
Les informations sur l'invalidation des itérateurs sont copiées depuis ici

Table des matières

Paramètres

pos - un itérateur vers la position avant laquelle le nouvel élément sera inséré
value - une valeur d'élément à insérer
first, last - la paire d'itérateurs définissant la plage source des éléments à insérer
ilist - une liste d'initialisation depuis laquelle insérer les valeurs
x - une valeur de tout type pouvant être comparée de manière transparente avec une clé
s - une balise de désambiguïsation indiquant que la séquence d'entrée est triée (par rapport à value_comp() ) et ne contient que des éléments uniques
Exigences de type
-
InputIt doit satisfaire aux exigences de LegacyInputIterator .

Valeur de retour

1,2) Une paire constituée d'un itérateur vers l'élément inséré (ou vers l'élément qui a empêché l'insertion) et une valeur bool définie à true si et seulement si l'insertion a eu lieu.
3,4) Un itérateur vers l'élément inséré, ou vers l'élément qui a empêché l'insertion.
5) Une paire constituée d'un itérateur vers l'élément inséré (ou vers l'élément qui a empêché l'insertion) et d'une bool valeur définie à true si et seulement si l'insertion a eu lieu.
6) Un itérateur vers l'élément inséré, ou vers l'élément qui a empêché l'insertion.
7-10) (aucun)

Exceptions

1-6) Si une exception est levée par une opération quelconque, l'insertion n'a aucun effet.
Cette section est incomplète
Raison : cas 7-10

Complexité

1-6) Linéaire en size() .
7) N + M·log ( M ) , où N est la size() avant l'opération et M est std:: distance ( first, last ) .
8) Linéaire en size() .
9) N + M·log ( M ) , où N est la size() avant l'opération et M est ilist. size ( ) .
10) Linéaire en N , où N est size() après l'opération.

Notes

L'insertion avec indice ( ( 3,4 ) et ( 6 ) ) ne retourne pas un booléen afin d'être compatible en signature avec l'insertion positionnelle sur les conteneurs séquentiels, tels que std::vector::insert . Cela permet de créer des inserters génériques tels que std::inserter . Une manière de vérifier le succès d'une insertion avec indice est de comparer size() avant et après.

Exemple

Cette section est incomplète
Raison : aucun exemple

Voir aussi

construit un élément en place
(fonction membre publique)
construit des éléments en place en utilisant un indice
(fonction membre publique)
insère un élément ou assigne à l'élément actuel si la clé existe déjà
(fonction membre publique)
crée un std::insert_iterator du type déduit de l'argument
(modèle de fonction)