Namespaces
Variants

std::flat_set<Key,Compare,KeyContainer>:: insert

From cppreference.net
C++
Containers library
std::flat_set
Member types
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 K >
iterator insert ( const_iterator pos, K && x ) ;
(5) (depuis C++23)
template < class InputIt >
void insert ( InputIt first, InputIt last ) ;
(6) (depuis C++23)
template < class K >
std:: pair < iterator, bool > insert ( K && x ) ;
(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 la plus proche possible de celle située juste avant pos . Équivalent à return emplace_hint ( pos, std :: move ( value ) ) ; .
5,7) Si * this contient déjà un élément qui se compare de manière équivalente à x , ne fait rien. Sinon, insère un nouvel élément comme suit :
  • (5) emplace ( pos, std:: forward < K > ( x ) ) (à une position aussi proche que possible de la position juste avant pos );
  • (7) emplace ( std:: forward < K > ( x ) ) .
La conversion de x vers key_type doit construire un objet u pour lequel find ( k ) == find ( u ) est true . Sinon, le comportement est indéfini.
Ces surcharges participent à la résolution de surcharge seulement si
  • L'identifiant qualifié Compare::is_transparent est valide et désigne un type, et
  • std:: is_constructible_v < value_type, K > est true ,
ce qui permet ensemble d'appeler cette fonction sans construire une instance de Key .
6) Équivalent à la séquence d'opérations :
  1. Insère les éléments de l'intervalle [ first , last ) comme par c. insert ( c. end ( ) , first, last ) ; .
  2. Trie l'intervalle des éléments nouvellement insérés par rapport à compare .
  3. Fusionne l'intervalle trié résultant et l'intervalle trié des éléments préexistants en un seul intervalle trié. (Note : l'opération de fusion peut allouer de la mémoire).
  4. Efface tous sauf le premier élément de chaque groupe d'éléments équivalents consécutifs.
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 la plage [ first , last ) . Équivalent à insert ( first, last ) ; .
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 - itérateur vers la position avant laquelle le nouvel élément sera inséré
value - valeur de l'élément à insérer
first, last - la paire d'itérateurs définissant la plage source des éléments à insérer
ilist - 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 à compare ) 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-5) Un itérateur vers l'élément inséré, ou vers l'élément qui a empêché l'insertion.
6) (aucun)
7) 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.
8-10) (aucun)

Exceptions

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

Complexité

1,2) Logarithmique en size() , plus le coût de l'insertion dans c .
3-5) Amorti constant si l'insertion se produit à la position juste avant pos , logarithmique dans size() sinon. Plus le coût de l'insertion dans c .
6) N + M·log ( M ) , où N est la size() avant l'opération et M est std:: distance ( first, last ) .
7) Logarithmique en size() , plus le coût de l'insertion dans c .
8) Linéaire en N , où N est size() après l'opération.
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-5 ) 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

Exécuter ce code 
#include <cassert>
#include <flat_set>
#include <iostream>
int main()
{
    std::flat_set<int> set;
    auto result_1 = set.insert(3);
    assert(result_1.first != set.end()); // c'est un itérateur valide
    assert(*result_1.first == 3);
    if (result_1.second)
        std::cout << "insert done\n";
    auto result_2 = set.insert(3);
    assert(result_2.first == result_1.first); // le même itérateur
    assert(*result_2.first == 3);
    if (!result_2.second)
        std::cout << "no insertion\n";
}

Sortie : 

insert done
no insertion

Voir aussi

construit un élément en place
(fonction membre publique)
construit des éléments en place en utilisant un indice
(fonction membre publique)
crée un std::insert_iterator dont le type est déduit de l'argument
(fonction template)