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

Insère un nouvel élément dans le conteneur construit sur place avec les args donnés, s'il n'existe aucun élément avec la clé dans le conteneur.

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 ) ... . L'élément peut être construit même s'il existe déjà un élément avec la clé dans le conteneur, auquel cas le nouvel élément construit sera immédiatement détruit (voir try_emplace() si ce comportement n'est pas souhaitable).

Si value_type n'est pas EmplaceConstructible dans unordered_map à 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

Une paire constituée d'un itérateur vers l'élément inséré (ou vers l'élément qui a empêché l'insertion) et d'une bool valeur définie à true si et seulement si l'insertion a eu lieu.

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_map<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 conversion par déplacement de pair
    m.emplace(std::make_pair("b", "abcd"));
    // utilise le constructeur template de pair
    m.emplace("d", "ddd");
    // emplace avec une clé dupliquée n'a aucun effet
    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'));
    // une alternative est : m.try_emplace("c", 10, 'c');
    for (const auto& p : m)
        std::cout << p.first << " => " << p.second << '\n';
}

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

Voir aussi