std::unordered_multimap<Key,T,Hash,KeyEqual,Allocator>:: emplace

Insère un nouvel élément dans le conteneur construit sur place avec les args donnés.

Le constructeur du nouvel élément (c'est-à-dire std:: pair < const Key, T > ) est appelé avec exactement les mêmes arguments que ceux fournis à emplace , transmis via std:: forward < Args > ( args ) ... .

Si value_type n'est pas EmplaceConstructible dans unordered_multimap à partir de args , le comportement est indéfini.

Si après l'opération le nouveau nombre d'éléments est supérieur à l'ancien max_load_factor() * bucket_count() un rehashing a lieu.
Si un rehashing se produit (en raison de l'insertion), tous les itérateurs sont invalidés. Sinon (aucun rehashing), les itérateurs ne sont pas invalidés.

Paramètres

Valeur de retour

Un itérateur vers l'élément inséré.

Exceptions

Si une exception est levée pour quelque raison que ce soit, cette fonction n'a aucun effet ( garantie forte de sûreté face aux exceptions ).

Complexité

Amorti constant en moyenne, pire cas linéaire dans la taille du conteneur.

Notes

L'utilisation judicieuse de emplace permet de construire le nouvel élément tout en évitant les opérations inutiles de copie ou de déplacement.

Exemple

#include <iostream>
#include <string>
#include <utility>
#include <unordered_map>
int main()
{
    std::unordered_multimap<std::string, std::string> m;
    // utilise le constructeur de déplacement de pair
    m.emplace(std::make_pair(std::string("a"), std::string("a")));
    // utilise le constructeur de déplacement convertissant de pair
    m.emplace(std::make_pair("b", "abcd"));
    // utilise le constructeur template de pair
    m.emplace("d", "ddd");
    // emplace avec clé dupliquée
    m.emplace("d", "DDD");
    // utilise le constructeur piecewise de pair
    m.emplace(std::piecewise_construct,
              std::forward_as_tuple("c"),
              std::forward_as_tuple(10, 'c'));
    for (const auto& p : m)
        std::cout << p.first << " => " << p.second << '\n';
}

a => a
b => abcd
c => cccccccccc
d => ddd
d => DDD

Voir aussi