std::unordered_map<Key,T,Hash,KeyEqual,Allocator>:: operator[]

Retourne une référence à la valeur qui est mappée à une clé équivalente à key ou x respectivement, en effectuant une insertion si une telle clé n'existe pas déjà.

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

Exceptions

Si une exception est levée par une opération quelconque, l'insertion n'a aucun effet.

Complexité

Cas moyen : constant, cas le plus défavorable : linéaire en taille.

Notes

Dans les normes publiées C++11 et C++14, cette fonction était spécifiée comme nécessitant que mapped_type soit DefaultInsertable et que key_type soit CopyInsertable ou MoveInsertable dans * this . Cette spécification était défectueuse et a été corrigée par LWG issue 2469 , et la description ci-dessus intègre la résolution de ce problème.

Cependant, une implémentation (libc++) est connue pour construire les objets key_type et mapped_type via deux appels séparés à l'allocateur construct() , comme l'exigent vraisemblablement les standards publiés, plutôt que de construire directement un objet value_type .

operator [ ] n'est pas constant car il insère la clé si elle n'existe pas. Si ce comportement est indésirable ou si le conteneur est const , at peut être utilisé.

Exemple

#include <iostream>
#include <string>
#include <unordered_map>
void println(auto const comment, auto const& map)
{
    std::cout << comment << '{';
    for (const auto& pair : map)
        std::cout << '{' << pair.first << ": " << pair.second << '}';
    std::cout << "}\n";
}
int main()
{
    std::unordered_map<char, int> letter_counts{{'a', 27}, {'b', 3}, {'c', 1}};
    println("letter_counts initially contains: ", letter_counts);
    letter_counts['b'] = 42; // updates an existing value
    letter_counts['x'] = 9;  // inserts a new value
    println("after modifications it contains: ", letter_counts);
    // count the number of occurrences of each word
    // (the first call to operator[] initialized the counter with zero)
    std::unordered_map<std::string, int>  word_map;
    for (const auto& w : {"this", "sentence", "is", "not", "a", "sentence",
                          "this", "sentence", "is", "a", "hoax"})
        ++word_map[w];
    word_map["that"]; // just inserts the pair {"that", 0}
    for (const auto& [word, count] : word_map)
        std::cout << count << " occurrence(s) of word '" << word << "'\n";
}

letter_counts initially contains: {{a: 27}{b: 3}{c: 1}}
after modifications it contains: {{a: 27}{b: 42}{c: 1}{x: 9}}
2 occurrence(s) of word 'a'
1 occurrence(s) of word 'hoax'
2 occurrence(s) of word 'is'
1 occurrence(s) of word 'not'
3 occurrence(s) of word 'sentence'
0 occurrence(s) of word 'that'
2 occurrence(s) of word 'this'

Voir aussi