T& operator[]( const Key& key ); | (1) | |
T& operator[]( Key&& key ); | (2) | (since C++11) |
Returns a reference to the value that is mapped to a key equivalent to key, performing an insertion if such key does not already exist.
| 1) Inserts value_type(key, T()) if the key does not exist. This function is equivalent to return insert(std::make_pair(key, T())).first->second;
| (until C++11) | ||||||
| 1) Inserts a value_type object constructed in-place from std::piecewise_construct, std::forward_as_tuple(key), std::tuple<>() if the key does not exist. This function is equivalent to return this->try_emplace(key).first->second;. (since C++17) When the default allocator is used, this results in the key being copy constructed from key and the mapped value being value-initialized.
2) Inserts a 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. This function is equivalent to return this->try_emplace(std::move(key)).first->second;. (since C++17) When the default allocator is used, this results in the key being move constructed from key and the mapped value being value-initialized.
| (since C++11) | ||||||
No iterators or references are invalidated.
Parameters
| key | - | the key of the element to find |
Return value
Reference to the mapped value of the new element if no element with key key existed. Otherwise a reference to the mapped value of the existing element whose key is equivalent to key.
Exceptions
If an exception is thrown by any operation, the insertion has no effect.
Complexity
Logarithmic in the size of the container.
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.
Example
This example demonstrates how to modify existing values and insert new values using operator[]:
#include <iostream>
#include <map>
int main()
{
std::map<char, int> letter_counts {{'a', 27}, {'b', 3}, {'c', 1}};
std::cout << "initially:\n";
for (const auto &pair : letter_counts) {
std::cout << pair.first << ": " << pair.second << '\n';
}
letter_counts['b'] = 42; // update an existing value
letter_counts['x'] = 9; // insert a new value
std::cout << "after modifications:\n";
for (const auto &pair : letter_counts) {
std::cout << pair.first << ": " << pair.second << '\n';
}
}Output:
initially: a: 27 b: 3 c: 1 after modifications: a: 27 b: 42 c: 1 x: 9
The following example counts the occurrences of each word in a vector of strings:
#include <string>
#include <iostream>
#include <vector>
#include <map>
int main()
{
std::vector<std::string> words = {
"this", "sentence", "is", "not", "a", "sentence",
"this", "sentence", "is", "a", "hoax"
};
std::map<std::string, size_t> word_map;
for (const auto &w : words) {
++word_map[w];
}
for (const auto &pair : word_map) {
std::cout << pair.second
<< " occurrences of word '"
<< pair.first << "'\n";
}
}Output:
1 occurrences of word 'hoax' 2 occurrences of word 'this' 2 occurrences of word 'a' 2 occurrences of word 'is' 1 occurrences of word 'not' 3 occurrences of word 'sentence'
See also
| (C++11) | 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) |
Please login to continue.