std::map<Key,T,Compare,Allocator>::operator[] - cppreference.com (original) (raw)

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.

1. Inserts a value_type object constructed in-place if there is no key that transparently compares equivalent to the value x.

Equivalent to return this->try_emplace(std::forward<K>(x)).first->second;. This overload participates in overload resolution only if Compare is transparent. It allows calling this function without constructing an instance of Key.

No iterators or references are invalidated.

Contents

• 1 Parameters
• 2 Return value
• 3 Exceptions
• 4 Complexity
• 5 Notes
• 6 Example
• 7 Defect reports
• 8 See also

[edit] Parameters

[edit] Return value

1,2) A 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.

1. A reference to the mapped value of the new element if no element with key that compares equivalent to the value x existed. Otherwise, a reference to the mapped value of the existing element whose key compares equivalent to x.

[edit] Exceptions

If an exception is thrown by any operation, the insertion has no effect.

[edit] Complexity

Logarithmic in the size of the container.

[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.

[edit] Example

#include #include #include   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::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::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"; }

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'

Defect reports

The following behavior-changing defect reports were applied retroactively to previously published C++ standards.

[edit] See also

| | access specified element with bounds checking (public member function) [edit] | | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | | inserts an element or assigns to the current element if the key already exists (public member function) [edit] | | | inserts in-place if the key does not exist, does nothing if the key exists (public member function) [edit] |