std::unordered_map::operator[] - cppreference.com

##### cppreference.com

##### Search

Create account

##### Namespaces

- Page
- Discussion

##### Variants

##### Views

- View
- Edit
- History

##### Actions

# std::unordered_map::operator[]

From cppreference.com
< cpp‎ | container‎ | unordered map

T& operator[]( const Key& key ); | (1) | (since C++11)
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)

If an insertion occurs and results in a rehashing of the container, all iterators are invalidated. Otherwise iterators are not affected. References are not invalidated. Rehashing occurs only if the new number of elements is equal to or greater than max_load_factor()*bucket_count().

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

Average case: constant, worst case: linear in size.

### [edit] Example

This example demonstrates how to modify existing values and insert new values using `operator[]`:

Run this code

    #include <iostream>
    #include <unordered_map>

    int main()
    {
        std::unordered_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:

Run this code

    #include <string>
    #include <iostream>
    #include <vector>
    #include <unordered_map>

    int main()
    {
        std::vector<std::string> words = {
            "this", "sentence", "is", "not", "a", "sentence",
    	"this", "sentence", "is", "a", "hoax"
        };

        std::unordered_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

at | access specified element with bounds checking (public member function) [edit]

Retrieved from "http://en.cppreference.com/mwiki/index.php?title=cpp/container/unordered_map/operator_at&oldid=44650"