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
maps (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
|