Namespaces
Variants

    std::multimap<Key,T,Compare,Allocator>:: multimap

    From fr.cppreference.net

    C++
    Containers library
    std::multimap
    Member functions
    Non-member functions
    Deduction guides (C++17)
    (1)
    multimap ( ) ;
    		(jusqu'à C++11)
    multimap ( ) : multimap ( Compare ( ) ) { }
    		(depuis C++11)
    (constexpr depuis C++26)
    explicit multimap ( const Compare & comp,
    const Allocator & alloc = Allocator ( ) ) ;
    		(2) (constexpr depuis C++26)
    explicit multimap ( const Allocator & alloc ) ;
    		(3) (depuis C++11)
    (constexpr depuis C++26)
    template < class InputIt >

    multimap ( InputIt first, InputIt last,
    const Compare & comp = Compare ( ) ,

    const Allocator & alloc = Allocator ( ) ) ;
    		(4) (constexpr depuis C++26)
    template < class InputIt >

    multimap ( InputIt first, InputIt last,
    const Allocator & alloc )

    : multimap ( first, last, Compare ( ) , alloc ) { }
    		(5) (depuis C++14)
    (constexpr depuis C++26)
    multimap ( const multimap & other ) ;
    		(6) (constexpr depuis C++26)
    multimap ( const multimap & other, const Allocator & alloc ) ;
    		(7) (depuis C++11)
    (constexpr depuis C++26)
    multimap ( multimap && other ) ;
    		(8) (depuis C++11)
    (constexpr depuis C++26)
    multimap ( multimap && other, const Allocator & alloc ) ;
    		(9) (depuis C++11)
    (constexpr depuis C++26)
    multimap ( std:: initializer_list < value_type > init,

    const Compare & comp = Compare ( ) ,

    const Allocator & alloc = Allocator ( ) ) ;
    		(10) (depuis C++11)
    (constexpr depuis C++26)
    multimap ( std:: initializer_list < value_type > init,

    const Allocator & alloc )

    : multimap ( init, Compare ( ) , alloc ) { }
    		(11) (depuis C++14)
    (constexpr depuis C++26)
    template < container-compatible-range < value_type > R >

    multimap ( std:: from_range_t , R && rg,
    const Compare & comp = Compare ( ) ,

    const Allocator & alloc = Allocator ( ) ) ;
    		(12) (depuis C++23)
    (constexpr depuis C++26)
    template < container-compatible-range < value_type > R >

    multimap ( std:: from_range_t , R && rg,
    const Allocator & alloc )

    : multimap ( std:: from_range , std:: forward < R > ( rg ) , Compare ( ) , alloc ) { }
    		(13) (depuis C++23)
    (constexpr depuis C++26)

    Construit un nouveau conteneur à partir de diverses sources de données et optionnellement en utilisant l'allocateur fourni par l'utilisateur alloc ou l'objet fonction de comparaison comp .

    1-3) Construit un conteneur vide.
    4,5) Construit le conteneur avec le contenu de la plage [ first , last ) .
    Si [ first , last ) n'est pas un intervalle valide , le comportement est indéfini.
    6,7) Construit le conteneur avec la copie du contenu de other .

    Si alloc n'est pas fourni, l'allocateur est obtenu en appelant std:: allocator_traits < allocator_type > ::
    select_on_container_copy_construction ( other. get_allocator ( ) )     .

    		(depuis C++11)

    Pendant la déduction d'arguments de modèle de classe , seul le premier argument contribue à la déduction du paramètre de modèle Allocator du conteneur.

    		(depuis C++23)
    8,9) Construit le conteneur avec le contenu de other en utilisant la sémantique de déplacement. Si alloc n'est pas fourni, l'allocateur est obtenu par construction par déplacement depuis l'allocateur appartenant à other .

    Pendant la déduction d'arguments de modèle de classe , seul le premier argument contribue à la déduction du paramètre de modèle Allocator du conteneur.

    		(since C++23)
    10,11) Construit le conteneur avec le contenu de la liste d'initialisation init .
    12,13) Construit le conteneur avec le contenu de rg .

    Contenu

    Paramètres

    alloc - allocateur à utiliser pour toutes les allocations de mémoire de ce conteneur
    comp - objet fonction de comparaison à utiliser pour toutes les comparaisons de clés
    first, last - la paire d'itérateurs définissant la plage source des éléments à copier
    other - un autre conteneur à utiliser comme source pour initialiser les éléments du conteneur
    init - liste d'initialisation pour initialiser les éléments du conteneur
    rg - une plage compatible avec le conteneur , c'est-à-dire une input_range dont les éléments sont convertibles en value_type
    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-3) Constant.
    4,5) N·log(N) où N est std:: distance ( first, last ) en général, linéaire en N si [ first , last ) est déjà trié selon value_comp ( ) .
    6,7) Linéaire en fonction de la taille de other .
    8,9) Constant. Si alloc est donné et alloc ! = other. get_allocator ( ) , alors linéaire.
    10,11) N·log(N) où N est init. size ( ) en général, linéaire en N si init est déjà trié par value_comp ( ) .
    12,13) N·log(N) où N est ranges:: distance ( rg ) en général, linéaire en N si rg est déjà trié selon value_comp ( ) .

    Exceptions

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

    Notes

    Après une construction par déplacement de conteneur (surcharge (8,9)), les références, pointeurs et itérateurs qui référençaient initialement des éléments dans other restent valides, mais référencent désormais des éléments qui se trouvent maintenant 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 le problème LWG issue 2321.

    Bien que cela ne soit pas formellement requis avant C++23, certaines implémentations ont déjà placé le paramètre de modèle Allocator dans des contextes non déduits dans les modes antérieurs.

    Test de fonctionnalité macro Valeur Norme Fonctionnalité
    __cpp_lib_containers_ranges 202202L (C++23) Construction et insertion conscientes des plages ; surcharges (12,13)

    Exemple

    Exécuter ce code 
    #include <iostream>
#include <map>
#include <utility>
struct Point { double x, y; };
struct PointCmp
{
    bool operator()(const Point& lhs, const Point& rhs) const
    {
        return lhs.x < rhs.x; // NB. ignores y on purpose
    }
};
template <typename Key, typename Value, typename Cmp>
void println(auto rem, const std::multimap<Key, Value, Cmp>& map)
{
    std::cout << rem << "{ ";
    for (auto n{map.size()}; const auto& p : map)
        std::cout << '[' << p.first << ":" << p.second << (--n ? "], " : "]");
    std::cout << " }\n";
}
int main()
{
    std::multimap<int, int> m1 =
    {
        {1, 1}, {2, 2}, {3, 3}, {4, 4}, {4, 4}, {3, 3}, {2, 2}, {1, 1}
    };
    println("m1 = ", m1);
    // Comparaison personnalisée
    std::multimap<Point, double, PointCmp> mag
    {
        {{5, 12}, 13},
        {{3, 4}, 5},
        {{8, 15}, 17},
        {{3, -3}, -1}
    };
    for (auto p : mag)
        std::cout << "La magnitude de (" << p.first.x << ", " << p.first.y << ")"
                     " est " << p.second << '\n';
    std::cout << "Construction à partir d'une plage :\n";
    using PS = std::pair<int, std::string>;
    const auto rg = {PS{3, "Earth"}, {2, "Venus"}, {1, "Mercury"}, {3, "Moon"}};
#if __cpp_lib_containers_ranges
    std::multimap<int, std::string> m2(std::from_range, rg); // surcharge (12)
#else
    std::multimap<int, std::string> m2(rg.begin(), rg.end()); // repli sur (4)
#endif
    println("m2 = ", m2);
}

    Sortie : 

    m1 = { [1:1], [1:1], [2:2], [2:2], [3:3], [3:3], [4:4], [4:4] }
La magnitude de (3, 4) est 5
La magnitude de (3, -3) est -1
La magnitude de (5, 12) est 13
La magnitude de (8, 15) est 17
Construction à partir d'une plage :
m2 = { [1:Mercury], [2:Venus], [3:Earth], [3:Moon] }

    Rapports de défauts

    Les rapports de défauts modifiant le comportement suivants ont été appliqués rétroactivement aux normes C++ précédemment publiées.

    DR Appliqué à Comportement publié Comportement corrigé
    LWG 2076 C++11 surcharge ( 4 ) conditionnellement requise Key et T pour être CopyInsertable dans * this non requis
    LWG 2193 C++11 le constructeur par défaut était explicite rendu non-explicite

    Voir aussi

    		assigne des valeurs au conteneur
    (fonction membre publique)