Namespaces
Variants

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

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

    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-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 du conteneur (surcharge (3,16-19)), les références, pointeurs et itérateurs qui se référaient initialement aux éléments dans other restent valides, mais se réfèrent désormais aux éléments qui se trouvent 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)