std::map
std::map
<map>
class Key,
class T,
class Compare = std::less <Key>,
class Allocator = std::allocator <std::pair <const Key, T>>
template<
class Key,
class T,
class Compare = std::less <Key>
> using map = std::map<Key, T, Compare,
std::pmr::polymorphic_allocator <std::pair <const Key, T>>>;
std::map
is a sorted associative container that contains key-value pairs with unique keys. Keys are sorted by using the comparison function Compare
. Search, removal, and insertion operations have logarithmic complexity. Maps are usually implemented as Red–black trees.
Iterators of std::map
iterate in ascending order of keys, where ascending is defined by the comparison that was used for construction. That is, given
- m, a
std::map
- it_l and it_r, dereferenceable iterators to m, with it_l < it_r.
m.value_comp()(*it_l, *it_r) == true (least to greatest if using the default comparison).
Everywhere the standard library uses the Compare requirements, uniqueness is determined by using the equivalence relation. In imprecise terms, two objects a and b are considered equivalent (not unique) if neither compares less than the other: !comp(a, b) && !comp(b, a).
std::map
meets the requirements of Container, AllocatorAwareContainer, AssociativeContainer and ReversibleContainer.
std::map
are constexpr: it is possible to create and use std::map
objects in the evaluation of a constant expression.However, std::map
objects generally cannot be constexpr, because any dynamically allocated storage must be released in the same evaluation of constant expression.
Contents
Template parameters
Reason: Add descriptions of the template parameters.
Member types
pointer
Allocator::pointer
std::allocator_traits <Allocator>::pointer
(since C++11)const_pointer
Allocator::const_pointer
std::allocator_traits <Allocator>::const_pointer
(since C++11)iterator
value_type
[edit]
const_iterator
reverse_iterator
const_reverse_iterator
node_type
(since C++17)
insert_return_type
(since C++17)
node_type
, a specialization oftemplate<class Iter, class NodeType>
struct /*unspecified*/
{
Iter position;
bool inserted;
NodeType node;
};
instantiated with template arguments iterator
and node_type
.[edit]
Member classes
Member functions
Element access
Iterators
Capacity
Modifiers
(public member function) [edit]
(public member function) [edit]
Lookup
(public member function) [edit]
Observers
value_type
(public member function) [edit]
Non-member functions
map
s (function template) [edit]
Deduction guides
(since C++17)Notes
Feature-test macro | Value | Std | Feature |
---|---|---|---|
__cpp_lib_containers_ranges |
202202L |
(C++23) | Ranges construction and insertion for containers |
__cpp_lib_constexpr_map |
202502L |
(C++26) | constexpr std::map
|
Example
#include <iostream> #include <map> #include <string> #include <string_view> void print_map(std::string_view comment, const std::map<std::string, int>& m) { std::cout << comment; // Iterate using C++17 facilities for (const auto& [key, value] : m) std::cout << '[' << key << "] = " << value << "; "; // C++11 alternative: // for (const auto& n : m) // std::cout << n.first << " = " << n.second << "; "; // // C++98 alternative: // for (std::map<std::string, int>::const_iterator it = m.begin(); it != m.end(); ++it) // std::cout << it->first << " = " << it->second << "; "; std::cout << '\n'; } int main() { // Create a map of three (string, int) pairs std::map<std::string, int> m{{"CPU", 10}, {"GPU", 15}, {"RAM", 20}}; print_map("1) Initial map: ", m); m["CPU"] = 25; // update an existing value m["SSD"] = 30; // insert a new value print_map("2) Updated map: ", m); // Using operator[] with non-existent key always performs an insert std::cout << "3) m[UPS] = " << m["UPS"] << '\n'; print_map("4) Updated map: ", m); m.erase("GPU"); print_map("5) After erase: ", m); std::erase_if (m, [](const auto& pair){ return pair.second > 25; }); print_map("6) After erase: ", m); std::cout << "7) m.size() = " << m.size() << '\n'; m.clear(); std::cout << std::boolalpha << "8) Map is empty: " << m.empty() << '\n'; }
Output:
1) Initial map: [CPU] = 10; [GPU] = 15; [RAM] = 20; 2) Updated map: [CPU] = 25; [GPU] = 15; [RAM] = 20; [SSD] = 30; 3) m[UPS] = 0 4) Updated map: [CPU] = 25; [GPU] = 15; [RAM] = 20; [SSD] = 30; [UPS] = 0; 5) After erase: [CPU] = 25; [RAM] = 20; [SSD] = 30; [UPS] = 0; 6) After erase: [CPU] = 25; [RAM] = 20; [UPS] = 0; 7) m.size() = 3 8) Map is empty: true
Defect reports
The following behavior-changing defect reports were applied retroactively to previously published C++ standards.
DR | Applied to | Behavior as published | Correct behavior |
---|---|---|---|
LWG 230 | C++98 | Key was not required to be CopyConstructible (a key of type Key might not be able to be constructed)
|
Key is also required tobe CopyConstructible |
LWG 464 | C++98 | accessing a const map by key was inconvenient
|
at function provided
|