Namespaces
Variants

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

From cppreference.net

C++
Containers library
std::flat_set
Member types
Member functions
Helper classes
Tags
Deduction guides
flat_set ( )
: flat_set ( key_compare ( ) ) { }
(1) (depuis C++23)
template < class Allocator >
flat_set ( const flat_set & other, const Allocator & alloc ) ;
(2) (depuis C++23)
template < class Allocator >
flat_set ( flat_set && other, const Allocator & alloc ) ;
(3) (depuis C++23)
explicit flat_set ( container_type cont,
const key_compare & comp = key_compare ( ) ) ;
(4) (depuis C++23)
template < class Allocator >
flat_set ( const container_type & cont, const Allocator & alloc ) ;
(5) (depuis C++23)
template < class Allocator >

flat_set ( const container_type & cont, const key_compare & comp,

const Allocator & alloc ) ;
(6) (depuis C++23)
flat_set ( std:: sorted_unique_t s, container_type cont,

const key_compare & comp = key_compare ( ) )

: c ( std :: move ( cont ) ) , compare ( comp ) { }
(7) (depuis C++23)
template < class Allocator >

flat_set ( std:: sorted_unique_t s, const container_type & cont,

const Allocator & alloc ) ;
(8) (depuis C++23)
template < class Allocator >

flat_set ( std:: sorted_unique_t s, const container_type & cont,

const key_compare & comp, const Allocator & alloc ) ;
(9) (depuis C++23)
explicit flat_set ( const key_compare & comp )
: c ( ) , compare ( comp ) { }
(10) (depuis C++23)
template < class Allocator >
flat_set ( const key_compare & comp, const Allocator & alloc ) ;
(11) (depuis C++23)
template < class Allocator >
explicit flat_set ( const Allocator & alloc ) ;
(12) (depuis C++23)
template < class InputIter >

flat_set ( InputIter first, InputIter last,
const key_compare & comp = key_compare ( ) )

: c ( ) , compare ( comp ) ;
(13) (depuis C++23)
template < class InputIter, class Allocator >

flat_set ( InputIter first, InputIter last,

const key_compare & comp, const Allocator & alloc ) ;
(14) (depuis C++23)
template < class InputIter, class Allocator >
flat_set ( InputIter first, InputIter last, const Allocator & alloc ) ;
(15) (depuis C++23)
template < container-compatible-range < value_type > R >

flat_set ( std:: from_range_t , R && rg, const key_compare & comp )

: flat_set ( comp ) ;
(16) (depuis C++23)
template < container-compatible-range < value_type > R >

flat_set ( std:: from_range_t fr, R && rg )

: flat_set ( fr, std:: forward < R > ( rg ) , key_compare ( ) ) { }
(17) (depuis C++23)
template < container-compatible-range < value_type > R, class Allocator >
flat_set ( std:: from_range_t , R && rg, const Allocator & alloc ) ;
(18) (depuis C++23)
template < container-compatible-range < value_type > R, class Allocator >

flat_set ( std:: from_range_t , R && rg, const key_compare & comp,

const Allocator & alloc ) ;
(19) (depuis C++23)
template < class InputIter >

flat_set ( std:: sorted_unique_t s, InputIter first, InputIter last,
const key_compare & comp = key_compare ( ) )

: c ( first, last ) , compare ( comp ) { }
(20) (depuis C++23)
template < class InputIter, class Allocator >

flat_set ( std:: sorted_unique_t s, InputIter first, InputIter last,

const key_compare & comp, const Allocator & alloc ) ;
(21) (depuis C++23)
template < class InputIter, class Allocator >

flat_set ( std:: sorted_unique_t s, InputIter first, InputIter last,

const Allocator & alloc ) ;
(22) (depuis C++23)
flat_set ( std:: initializer_list < value_type > init,

const key_compare & comp = key_compare ( ) )

: flat_set ( init. begin ( ) , init. end ( ) , comp ) { }
(23) (depuis C++23)
template < class Allocator >

flat_set ( std:: initializer_list < value_type > init, const key_compare & comp,

const Allocator & alloc ) ;
(24) (depuis C++23)
template < class Allocator >
flat_set ( std:: initializer_list < value_type > init, const Allocator & alloc ) ;
(25) (depuis C++23)
flat_set ( std:: sorted_unique_t s, std:: initializer_list < value_type > init,

const key_compare & comp = key_compare ( ) )

: flat_set ( s, init. begin ( ) , init. end ( ) , comp ) { }
(26) (depuis C++23)
template < class Allocator >

flat_set ( std:: sorted_unique_t s, std:: initializer_list < value_type > init,

const key_compare & comp, const Allocator & alloc ) ;
(27) (depuis C++23)
template < class Allocator >

flat_set ( std:: sorted_unique_t s, std:: initializer_list < value_type > init,

const Allocator & alloc ) ;
(28) (depuis C++23)

Construit un nouvel adaptateur de conteneur à partir de diverses sources de données et éventuellement d'un objet de fonction de comparaison fourni comp et/ou d'un allocateur alloc .

1) Un constructeur par défaut. Construit un adaptateur de conteneur vide.
2) Un constructeur de copie . Construit c avec la copie du contenu de other. c et compare avec other. compare . Voir la note d'utilisation de l'allocateur ci-dessous.
3) Un move constructor . Construit l'adaptateur de conteneur avec le contenu de other en utilisant la sémantique de déplacement. Voir la note d'utilisation de l'allocateur ci-dessous.
4) Construit le conteneur sous-jacent avec le contenu du conteneur cont . Initialise d'abord c avec std :: move ( cont ) et compare avec comp . Trie ensuite c par rapport à comp . Enfin, rend les éléments uniques, c'est-à-dire supprime tous les éléments sauf le premier de chaque groupe d'éléments équivalents consécutifs.
5) Identique à (4) , équivalent à flat_set ( cont ) ; . Voir note d'utilisation de l'allocateur ci-dessous.
6) Identique à (4) , équivalent à flat_set ( cont, comp ) ; . Voir note d'utilisation de l'allocateur ci-dessous.
7) Construit le conteneur sous-jacent avec le contenu de l'autre conteneur cont . Initialise c avec std :: move ( cont ) et compare avec comp .
8) Identique à (7) , équivalent à flat_set ( s, cont ) ; . Voir la note d'utilisation de l'allocateur ci-dessous.
9) Identique à (7) , équivalent à flat_set ( s, cont, comp ) ; . Voir note d'utilisation de l'allocateur ci-dessous.
10) Construit un conteneur adaptateur vide.
11,12) Construit un adaptateur de conteneur vide. Voir la note d'utilisation de l'allocateur ci-dessous.
13) Construit l'adaptateur de conteneur avec le contenu de la plage [ first , last ) , équivalent à insert ( first, last ) ; .
14,15) Identique à (13) . Voir la note d'utilisation de l'allocateur ci-dessous.
16) Construit l'adaptateur de conteneur avec le contenu de la plage rg . D'abord, utilise (10) comme constructeur déléguant . Puis initialise c avec le contenu de rg comme si par insert_range ( std:: forward < R > ( rg ) ) ; .
17) Identique à (16) en l'utilisant comme delegating constructor .
18,19) Identique à (16) . Voir la note d'utilisation de l'allocateur ci-dessous.
20) Construit le conteneur sous-jacent avec le contenu de la plage [ first , last ) . Initialise c avec c ( first, last ) et compare avec compare ( comp ) .
21,22) Identique à (20) . Voir la note d'utilisation de l'allocateur ci-dessous.
23) Un initializer-list constructor . Construit le conteneur sous-jacent avec le contenu de la liste d'initialisation init , en utilisant (13) comme delegating constructor .
24,25) Identique à (23) . Voir la note d'utilisation de l'allocateur ci-dessous.
26) Un initializer-list constructor . Construit le conteneur sous-jacent avec le contenu de la liste d'initialisation init , en utilisant (20) comme delegating constructor .
27,28) Enregistrer comme (26) . Voir note d'utilisation de l'allocateur ci-dessous.

Note pour les surcharges (13-15,20-22) : Si [ first , last ) n'est pas un intervalle valide , le comportement est indéfini.

Note for overloads (4-6,13-19,23-25) : If multiple elements in the range have keys that compare equivalent, it is unspecified which element is inserted (pending LWG2844 ).

Table des matières

Note d'utilisation de l'allocateur

Les constructeurs (2,3,5,6,8,9,11,12,14,15,17,19,21,22,24,25,27,28) sont équivalents aux constructeurs non-alloueurs correspondants, sauf que c est construit avec une construction uses-allocator . Ces surcharges participent à la résolution de surcharge seulement si std:: uses_allocator_v < container_type, Allocator > est true .

Paramètres

cont - un conteneur à utiliser comme source pour initialiser le conteneur sous-jacent
other - un autre flat_set à utiliser comme source pour initialiser les éléments du conteneur sous-jacent
alloc - un allocateur à utiliser pour toutes les allocations mémoire du conteneur sous-jacent
comp - un objet fonction à utiliser pour toutes les comparaisons de clés
first, last - la paire d'itérateurs définissant la plage source des éléments à copier
init - une liste d'initialisation pour initialiser les éléments du conteneur sous-jacent
rg - une plage compatible avec les conteneurs (c'est-à-dire une input_range dont les éléments sont convertibles en value_type ) à utiliser comme source pour initialiser le conteneur sous-jacent
fr - une balise de désambiguïsation indiquant que le membre contenu doit être construit par plage
s - une balise de désambiguïsation indiquant que la séquence d'entrée est triée par rapport à compare et que tous ses éléments sont uniques
Exigences de type
-
InputIt doit satisfaire aux exigences de LegacyInputIterator .
-
Compare doit satisfaire aux exigences de Compare .
-
Allocator doit satisfaire aux exigences de Allocator .

Complexité

1) Constante.
2) Linéaire en fonction de la taille de other .
3) Identique au constructeur par déplacement correspondant du conteneur encapsulé, c'est-à-dire constant ou linéaire en fonction de la taille de cont .
4-6) Linéaire en N si cont est trié par rapport à compare , sinon 𝓞(N·log(N)) , où N est la valeur de cont. size ( ) avant cet appel.
7-9) Identique au constructeur de déplacement correspondant du conteneur encapsulé, c'est-à-dire constant ou linéaire en fonction de la taille de cont .
10-12) Constant.
13-15) Linéaire en N si la plage d'entrée [ first , last ) est triée par rapport à compare , sinon 𝓞(N·log(N)) , où N est la valeur de cont. size ( ) avant cet appel.
16-19) Linéaire en N si la plage d'entrée rg est triée par rapport à compare , sinon 𝓞(N·log(N)) , où N est la valeur de cont. size ( ) avant cet appel.
20-22) Linéaire en fonction de la taille de [ first , last ) .
23-25) Linéaire en N si les éléments de init sont triés par rapport à compare , sinon 𝓞(N·log(N)) , où N est la valeur de cont. size ( ) avant cet appel.
26-28) Linéaire en fonction de la taille de init .

Exceptions

Les appels à Allocator::allocate peuvent lever une exception.

Notes

Après la construction par déplacement de conteneur (surcharge ( 3 ) ), les références, pointeurs et itérateurs (à l'exception de l'itérateur de fin) vers other restent valides, mais se réfèrent aux éléments qui se trouvent désormais dans * this . La norme actuelle garantit cela via l'énoncé général dans [container.reqmts]/67 , et une garantie plus directe est à l'étude via LWG issue 2321 .

Exemple

Cette section est incomplète
Raison : aucun exemple

Voir aussi

assigne des valeurs à l'adaptateur de conteneur
(fonction membre publique)