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

T& operator[]( const Key& key );

T& operator[]( Key&& key );

Возвращает ссылку на значение, сопоставленное с ключом, эквивалентным key, выполняя вставку, если такой ключ еще не существует.

Если после операции новое количество элементов превысит предыдущее max_load_factor() * bucket_count(), происходит перехеширование.
Если перехеширование происходит (из-за вставки), все итераторы становятся недействительными. В противном случае (без перехеширования), итераторы остаются действительными.

Параметры

Возвращаемое значение

Ссылка на сопоставленное значение нового элемента, если элемент с ключом key не существовал. В противном случае ссылка на сопоставленное значение существующего элемента, ключ которого эквивалентен key.

Исключения

Если при выполнении какой-либо операции возникло исключение, вставка не выполняется.

Сложность

Средний случай: постоянная, худший случай: линейная относительно размера.

Примечания

В опубликованных стандартах C++11 и C++14 эта функция должна была требовать, чтобы mapped_type был вставляемым по умолчанию, а key_type был копируемым для вставки или перемещаемым для вставки в *this. Данное требование было ошибочным и исправлено LWG issue 2469, и приведенное выше описание отражает решение этой проблемы.

Однако, известно, что одна реализация (libc++) создаёт объекты key_type и mapped_type с помощью двух отдельных вызовов аллокатора construct(), как это, по-видимому, требуют опубликованные стандарты, а не размещая объект value_type.

operator[] не является константной, потому что она вставляет ключ, если он не существует. Если это поведение нежелательно, или если контейнер const, можно использовать at().

Пример

#include <iostream>
#include <string>
#include <unordered_map>
 
auto print = [](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}};
 
    print("letter_counts initially contains: ", letter_counts);
 
    letter_counts['b'] = 42; // updates an existing value
    letter_counts['x'] = 9;  // inserts a new value
 
    print("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'

См. также