std::map::operator[]

From cppreference.com
< cpp‎ | container‎ | map
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.

If an insertion is performed, the mapped value is value-initialized (default-constructed for class types, zero-initialized otherwise) and a reference to it is returned.

1) Inserts value_type(key, T())
-
key_type must meet the requirements of CopyConstructible.
-
mapped_type must meet the requirements of DefaultConstructible. (since C++11)
2) Inserts value_type(std::move(key), T())
-
key_type must meet the requirements of MoveConstructible. (since C++11)
-
mapped_type must meet the requirements of DefaultConstructible. (since C++11)

No iterators or references are invalidated.

Contents

[edit] Parameters

key - the key of the element to find

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

[edit] Exceptions

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

[edit] Complexity

Logarithmic in the size of the container.

Notes

Until C++11, the overload (1) was specified to be equivalent to (insert(std::make_pair(key, T())).first)->second, which required T to be CopyConstructible.

[edit] 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'

[edit] See also

(C++11)
access specified element with bounds checking
(public member function)