std::map::operator[]

 

C++

Language

Standard library headers

Concepts

Utilities library

Strings library

Containers library

Algorithms library

Iterators library

Numerics library

Input/output library

Localizations library

Regular expressions library (C++11)

Atomic operations library (C++11)

Thread support library (C++11)

 

Containers library

array (C++11)

vector

deque

forward_list (C++11)

list

set

multiset

map

multimap

unordered_set (C++11)

unordered_multiset (C++11)

unordered_map (C++11)

unordered_multimap (C++11)

stack

queue

priority_queue

 

std::map

Member functions

map::map

map::~map

map::operator=

map::get_allocator

Element access

map::at

map::operator[]

Iterators

map::beginmap::cbegin (C++11)

map::endmap::cend (C++11)

map::rbeginmap::crbegin (C++11)

map::rendmap::crend (C++11)

Capacity

map::empty

map::size

map::max_size

Modifiers

map::clear

map::insert

map::insert_or_assign (C++17)

map::emplace (C++11)

map::emplace_hint (C++11)

map::try_emplace (C++17)

map::erase

map::swap

Lookup

map::count

map::find

map::equal_range

map::lower_bound

map::upper_bound

Observers

map::key_comp

map::value_comp

 

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.

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

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.

Example

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

Run this code

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

Run this code

#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

at (C++11)

access specified element with bounds checking (public member function)