std::unordered_map<Key,T,Hash,KeyEqual,Allocator>::operator[]
T& operator[]( const Key& key ); |
(1) | (since C++11) |
T& operator[]( Key&& key ); |
(2) | (since C++11) |
template< class K > T& operator[]( K&& x ); |
(3) | (since C++26) |
Returns a reference to the value that is mapped to a key equivalent to key or x respectively, performing an insertion if such key does not already exist.
value_type
object constructed in-place from std::piecewise_construct, std::forward_as_tuple(key), std::tuple<>() if the key does not exist.key
and the mapped value being value-initialized.
-value_type must be EmplaceConstructible from std::piecewise_construct, std::forward_as_tuple(key), std::tuple<>(). When the default allocator is used, this means that key_type must be CopyConstructible and mapped_type must be DefaultConstructible.
|
value_type
object constructed in-place from std::piecewise_construct, std::forward_as_tuple(std::move(key)), std::tuple<>() if the key does not exist.When the default allocator is used, this results in the key being move constructed from
key
and the mapped value being value-initialized.
-value_type must be EmplaceConstructible from std::piecewise_construct, std::forward_as_tuple(std::move(key)), std::tuple<>(). When the default allocator is used, this means that key_type must be MoveConstructible and mapped_type must be DefaultConstructible.
|
value_type
object constructed in-place if there is no key that transparently compares equivalent to the value x.This overload participates in overload resolution only if Hash::is_transparent and KeyEqual::is_transparent are valid and each denotes a type. This assumes that such Hash
is callable with both K
and Key
type, and that the KeyEqual
is transparent, which, together, allows calling this function without constructing an instance of Key
.
This section is incomplete Reason: add named requirements and mention default allocator |
If after the operation the new number of elements is greater than old max_load_factor()
*
bucket_count()
a rehashing takes place.
If rehashing occurs (due to the insertion), all iterators are invalidated. Otherwise (no rehashing), iterators are not invalidated.
Contents |
[edit] Parameters
key | - | the key of the element to find |
x | - | a value of any type that can be transparently compared with a key |
[edit] Return value
[edit] Exceptions
If an exception is thrown by any operation, the insertion has no effect.
[edit] Complexity
Average case: constant, worst case: linear in size.
[edit] Notes
In the published C++11 and C++14 standards, this function was specified to require mapped_type
to be DefaultInsertable and key_type
to be CopyInsertable or MoveInsertable into *this. This specification was defective and was fixed by LWG issue 2469, and the description above incorporates the resolution of that issue.
However, one implementation (libc++) is known to construct the key_type
and mapped_type
objects via two separate allocator construct()
calls, as arguably required by the standards as published, rather than emplacing a value_type
object.
operator[]
is non-const because it inserts the key if it doesn't exist. If this behavior is undesirable or if the container is const
, at()
may be used.
|
(since C++17) |
Feature-test macro | Value | Std | Feature |
---|---|---|---|
__cpp_lib_associative_heterogeneous_insertion |
202311L | (C++26) | Heterogeneous overloads for the remaining member functions in ordered and unordered associative containers. (3) |
[edit] Example
#include <iostream> #include <string> #include <unordered_map> void 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"; }
Possible output:
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'
[edit] See also
access specified element with bounds checking (public member function) | |
(C++17) |
inserts an element or assigns to the current element if the key already exists (public member function) |
(C++17) |
inserts in-place if the key does not exist, does nothing if the key exists (public member function) |