Namespaces
Variants

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

From cppreference.net

C++
Containers library
std::flat_map
Member types
Member functions
Non-member functions
Helper classes
Tags
Deduction guides
flat_map ( )
: flat_map ( key_compare ( ) ) { }
(1) (depuis C++23)
template < class Allocator >
flat_map ( const flat_map & , const Allocator & alloc ) ;
(2) (depuis C++23)
template < class Allocator >
flat_map ( flat_map && , const Allocator & alloc ) ;
(3) (depuis C++23)
flat_map ( key_container_type key_cont, mapped_container_type mapped_cont,
const key_compare & comp = key_compare ( ) ) ;
(4) (depuis C++23)
template < class Allocator >

flat_map ( const key_container_type & key_cont,
const mapped_container_type & mapped_cont,

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

flat_map ( const key_container_type & key_cont,
const mapped_container_type & mapped_cont,

const key_compare & comp, const Allocator & alloc ) ;
(6) (depuis C++23)
flat_map ( std:: sorted_unique_t , key_container_type key_cont,

mapped_container_type mapped_cont,

const key_compare & comp = key_compare ( ) ) ;
(7) (depuis C++23)
template < class Allocator >

flat_map ( std:: sorted_unique_t , const key_container_type & key_cont,

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

flat_map ( std:: sorted_unique_t , const key_container_type & key_cont,
const mapped_container_type & mapped_cont,

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

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

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

flat_map ( InputIter first, InputIter last,

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

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

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

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

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

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

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

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

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

flat_map ( 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_map ( std:: sorted_unique_t s, InputIter first, InputIter last,

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

const key_compare & comp = key_compare ( ) )

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

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

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

const key_compare & comp = key_compare ( ) )

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

flat_map ( 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_map ( 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 optionnellement en utilisant l'objet fonction de comparaison fourni par l'utilisateur comp et/ou l'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) Initialise d'abord c.keys avec std :: move ( key_cont ) , c.values avec std :: move ( mapped_cont ) , et compare avec comp . Trie ensuite la plage sous-jacente [ begin ( ) , end ( ) ) par rapport à value_comp() . Enfin, supprime les éléments dupliqués comme suit :
auto zv = views:: zip ( c. keys , c. values ) ;
auto it = ranges:: unique ( zv, key_equiv ( compare ) ) . begin ( ) ;
auto dist = distance ( zv. begin ( ) , it ) ;
c. keys . erase ( c. keys . begin ( ) + dist, c. keys . end ( ) ) ;
c. values . erase ( c. values . begin ( ) + dist, c. values . end ( ) ) ; .
5) Identique à (4) , équivalent à flat_map ( key_cont, mapped_cont ) ; . Voir note d'utilisation de l'allocateur ci-dessous.
6) Identique à (4) , équivalent à flat_map ( key_cont, mapped_cont, comp ) ; . Voir note d'utilisation de l'allocateur ci-dessous.
7) Initialise c.keys avec std :: move ( key_cont ) , c.values avec std :: move ( mapped_cont ) , et compare avec comp .
8) Identique à (7) , équivalent à flat_map ( s, key_cont, mapped_cont ) ; . Voir la note d'utilisation de l'allocateur ci-dessous.
9) Identique à (7) , équivalent à flat_map ( s, key_cont, mapped_cont, comp ) ; . Voir note d'utilisation de l'allocateur ci-dessous.
10) Construit un adaptateur de conteneur 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égué . 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 les conteneurs sous-jacents avec le contenu de la plage [ first , last ) comme si par insert ( first, last ) .
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-allocateur correspondants, sauf que les conteneurs sous-jacents c.keys et c.values sont construits avec une construction uses-allocator . Ces surcharges participent à la résolution de surcharge uniquement si std:: uses_allocator_v < container_type, Allocator > est true .

Paramètres

key_cont - un conteneur à utiliser comme source pour initialiser le conteneur de clés sous-jacent
mapped_cont - un conteneur à utiliser comme source pour initialiser le conteneur de valeurs sous-jacent
other - un autre flat_map à utiliser comme source pour initialiser les éléments des conteneurs sous-jacents
alloc - un allocateur à utiliser pour toutes les allocations mémoire des conteneurs sous-jacents
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 des conteneurs sous-jacents
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 les conteneurs sous-jacents
fr - une balise de désambiguïsation qui indique que le membre contenu doit être construit par plage
s - une balise de désambiguïsation qui indique que la séquence d'entrée est triée par rapport à value_comp() 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 à value_comp() , sinon 𝓞(N·log(N)) , où N est la valeur de key_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 à value_comp() , sinon 𝓞(N·log(N)) , où N est la valeur de key_cont. size ( ) avant cet appel.
16-19) Linéaire en N si la plage d'entrée rg est triée par rapport à value_comp() , sinon 𝓞(N·log(N)) , où N est la valeur de key_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 à value_comp() , sinon 𝓞(N·log(N)) , où N est la valeur de key_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 du 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)