Namespaces
Variants

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

    From fr.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 ).

    Sommaire

    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 qui se référaient à l'origine aux éléments dans other restent valides, mais se réfèrent aux éléments qui sont maintenant dans *this. La norme actuelle garantit cela via la déclaration générale 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)