std::map - cppreference.com (original) (raw)

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.

Contents

• 1 Template parameters
• 2 Member types
• 3 Member classes
• 4 Member functions
  • 4.1 Element access
  • 4.2 Iterators
  • 4.3 Capacity
  • 4.4 Modifiers
  • 4.5 Lookup
  • 4.6 Observers
• 5 Non-member functions
• 6 Deduction guides
• 7 Notes
• 8 Example
• 9 Defect reports
• 10 See also

[edit] Template parameters

[edit] Member types

[edit] Member classes

[edit] Member functions

[edit] Non-member functions

[edit] Notes

[edit] Example

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

[edit] Defect reports

The following behavior-changing defect reports were applied retroactively to previously published C++ standards.

[edit] See also

| | collection of key-value pairs, sorted by keys (class template) [edit] | | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | | collection of key-value pairs, hashed by keys, keys are unique (class template) [edit] | | | adapts two containers to provide a collection of key-value pairs, sorted by unique keys (class template) [edit] |