std::map

 

C++

Compiler-Unterstützung

Freestanding und gehostet

Sprache

Standardbibliothek

Header der Standardbibliothek

Benannte Anforderungen

Feature-Test-Makros (C++20)

Bibliothek für Sprachunterstützung

Konzepte-Bibliothek (C++20)

Diagnostik-Bibliothek

Speicherverwaltungsbibliothek

Metaprogrammierungsbibliothek (C++11)

Allgemeine Dienstprogramme-Bibliothek

Container-Bibliothek

Iterator-Bibliothek

Ranges-Bibliothek (C++20)

Algorithmen-Bibliothek

Bibliothek für Zeichenketten

Textverarbeitungsbibliothek

Numerik-Bibliothek

Datums- und Zeitbibliothek

Ein-/Ausgabe-Bibliothek

Dateisystembibliothek (C++17)

Unterstützung für nebenläufige Programmierung (C++11)

Ausführungssteuerungsbibliothek (C++26)

Technische Spezifikationen

Symbolverzeichnis

Externe Bibliotheken

 

Container-Bibliothek

Sequenz

array (C++11)

vector

vector<bool>

inplace_vector (C++26)

hive (C++26)

deque

forward_list (C++11)

list

Assoziativ

setzt

multiset

map

multimap

Ungeordnete assoziative

unordered_set (C++11)

unordered_multiset (C++11)

unordered_map (C++11)

unordered_multimap (C++11)

Adapter

stack

queue

priority_queue

flat_set (C++23)

flat_multiset (C++23)

flat_map (C++23)

flat_multimap (C++23)

Ansichten

span (C++20)

mdspan (C++23)

Tabellen

Iterator-Invalidierung

Mitgliedsfunktionstabelle

Nicht-Mitgliedsfunktionstabelle

 

std::map

Memberfunktionen

map::map map::~map               map::operator= map::get_allocator

Elementzugriff map::at map::operator[] Iteratoren map::beginmap::cbegin (C++11) map::endmap::cend (C++11) map::rbeginmap::crbegin (C++11)      map::rendmap::crend (C++11) Kapazität map::size map::max_size map::empty Observer map::key_comp map::value_comp Modifizierer map::clear map::insert map::erase map::swap map::extract (C++17) map::merge (C++17) map::insert_range (C++23) map::insert_or_assign (C++17) map::emplace (C++11) map::emplace_hint (C++11) map::try_emplace (C++17) Suche map::count map::find map::contains (C++20) map::equal_range map::lower_bound map::upper_bound

Nicht-Member-Funktionen

operator==operator<=> (C++20) std::swap(std::map) erase_if(std::map) (C++20)   operator!=operator<operator>operator<=operator>= (bis C++20)(bis C++20)(bis C++20)(bis C++20)(bis C++20)

Leitfaden zur Ableitung (C++17)

 

Definiert in Header <map>
template<     class Key,     class T,     class Compare = std::less<Key>,     class Allocator = std::allocator<std::pair<const Key, T>> > class map;	(1)
namespace pmr {     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>>>; }	(2)	(seit C++17)

std::map ist ein sortierter assoziativer Container, der Schlüssel-Wert-Paare mit eindeutigen Schlüsseln enthält. Schlüssel werden mithilfe der Vergleichsfunktion Compare sortiert. Such-, Entfernungs- und Einfügeoperationen haben logarithmische Komplexität. Maps werden üblicherweise als Rot-Schwarz-Bäume implementiert.

Iteratoren von std::map iterieren in aufsteigender Reihenfolge der Schlüssel, wobei aufsteigend durch den für die Konstruktion verwendeten Vergleich definiert ist. Das heißt, gegeben

• m, eine std::map
• it_l und it_r, dereferenzierbare Iteratoren zu m, mit it_l < it_r.

m.value_comp()(*it_l, *it_r) == true (von klein nach groß, wenn der Standardvergleich verwendet wird).

Überall dort, wo die Standardbibliothek die Compare-Anforderungen verwendet, wird die Eindeutigkeit durch die Äquivalenzrelation bestimmt. Ungenau formuliert: Zwei Objekte a und b gelten als äquivalent (nicht eindeutig), wenn keines kleiner als das andere ist: !comp(a, b) && !comp(b, a).

std::map erfüllt die Anforderungen von Container, AllocatorAwareContainer, AssociativeContainer und ReversibleContainer.

Alle Member-Funktionen von std::map sind constexpr: Es ist möglich, std::map-Objekte in der Auswertung eines konstanten Ausdrucks zu erstellen und zu verwenden. Jedoch können std::map-Objekte im Allgemeinen nicht constexpr sein, da jeder dynamisch zugewiesene Speicher in derselben Auswertung eines konstanten Ausdrucks freigegeben werden muss.

(seit C++26)

Member-Typen

Typ	Definition
key_type	Key
mapped_type	T
value_type	std::pair<const Key, T>
size_type	Vorzeichenloser Ganzzahltyp (normalerweise std::size_t)
difference_type	Vorzeichenbehafteter Ganzzahltyp (normalerweise std::ptrdiff_t)
key_compare	Compare
allocator_type	Allocator
Referenz	value_type&
const_reference	const value_type&
Zeiger	Allocator::pointer (bis C++11) std::allocator_traits<Allocator>::pointer (seit C++11)
const_pointer	Allocator::const_pointer (bis C++11) std::allocator_traits<Allocator>::const_pointer (seit C++11)
iterator	LegacyBidirectionalIterator und ConstexprIterator(seit C++26) zu value_type
const_iterator	LegacyBidirectionalIterator und ConstexprIterator(seit C++26) zu const value_type
reverse_iterator	std::reverse_iterator<iterator>
const_reverse_iterator	std::reverse_iterator<const_iterator>
node_type (seit C++17)	eine Spezialisierung von node handle, die einen Containerknoten repräsentiert
insert_return_type (seit C++17)	Typ, der das Ergebnis des Einfügens eines node_type beschreibt, eine Spezialisierung von template<class Iter, class NodeType> struct /*unspecified*/ {     Iter     position;     bool     inserted;     NodeType node; }; instanziiert mit den Template-Argumenten iterator und node_type.

Member-Klassen

value_compare

vergleicht Objekte vom Typ value_type (class)

Member-Funktionen

(Konstruktor)	konstruiert die map (public member function)
(Destruktor)	destruiert die map (public member function)
operator=	weist dem Container Werte zu (public member function)
get_allocator	gibt den zugehörigen Allocator zurück (public member function)
Elementzugriff
at	Greift mit Überprüfung auf ein bestimmtes Element zu (public member function)
operator[]	greift auf ein Element zu oder fügt es ein (public member function)
Iteratoren
begincbegin (C++11)	gibt einen Iterator zum Anfang zurück (public member function)
endcend (C++11)	gibt einen Iterator zum Ende zurück (public member function)
rbegincrbegin (C++11)	gibt einen Reverse-Iterator zum Anfang zurück (public member function)
rendcrend (C++11)	gibt einen Reverse-Iterator zum Ende zurück (public member function)
Kapazität
empty	prüft, ob der Container leer ist (public member function)
size	Gibt die Anzahl der Elemente zurück (public member function)
max_size	Gibt die maximal mögliche Anzahl von Elementen zurück (public member function)
Modifizierer
clear	leert den Inhalt (public member function)
insert	fügt Elemente ein oder Knoten(seit C++17) (public member function)
insert_range (C++23)	fügt einen Bereich von Elementen ein (public member function)
insert_or_assign (C++17)	fügt ein Element ein oder weist einem vorhandenen Element einen Wert zu, falls der Schlüssel bereits existiert (public member function)
emplace (C++11)	konstruiert Elemente direkt (in-place) (public member function)
emplace_hint (C++11)	konstruiert Elemente "in place" unter Verwendung eines Hinweises (public member function)
try_emplace (C++17)	fügt "in place" ein, wenn der Schlüssel nicht existiert, tut nichts, wenn der Schlüssel existiert (public member function)
erase	entfernt Elemente (public member function)
swap	tauscht die Inhalte (public member function)
extract (C++17)	extrahiert Knoten aus dem Container (public member function)
merge (C++17)	fügt Knoten aus einem anderen Container zusammen (public member function)
Suche
zählt	gibt die Anzahl der Elemente zurück, die einem bestimmten Schlüssel entsprechen (public member function)
find	sucht ein Element mit einem bestimmten Schlüssel (public member function)
contains (C++20)	prüft, ob der Container ein Element mit einem bestimmten Schlüssel enthält (public member function)
equal_range	gibt den Bereich von Elementen zurück, die einem bestimmten Schlüssel entsprechen (public member function)
lower_bound	gibt einen Iterator zum ersten Element zurück, das *nicht kleiner* als der gegebene Schlüssel ist (public member function)
upper_bound	gibt einen Iterator zum ersten Element zurück, das *größer* als der gegebene Schlüssel ist (public member function)
Observer
key_comp	gibt die Funktion zurück, die Schlüssel vergleicht (public member function)
value_comp	gibt die Funktion zurück, die Schlüssel in Objekten vom Typ value_type vergleicht (public member function)

Nicht-Member-Funktionen

operator==operator!=operator<operator<=operator>operator>=operator<=> (entfernt in C++20)(entfernt in C++20)(entfernt in C++20)(entfernt in C++20)(entfernt in C++20)(C++20)	vergleicht zwei maps lexikographisch (function template)
std::swap(std::map)	spezialisiert den Algorithmus std::swap (function template)
erase_if(std::map) (C++20)	entfernt alle Elemente, die bestimmte Kriterien erfüllen (function template)

Deduction Guides

(seit C++17)

Hinweise

Feature-Test-Makro	Wert	Std	Feature
__cpp_lib_containers_ranges	202202L	(C++23)	Bereichskonstruktion und -einfügung für Container
__cpp_lib_constexpr_containers	202502L	(C++26)	constexpr std::map

Beispiel

Führen Sie diesen Code aus

#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';
}

Ausgabe

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

Fehlerberichte

Die folgenden Verhaltensändernden Fehlerberichte wurden rückwirkend auf zuvor veröffentlichte C++-Standards angewendet.

DR	angewendet auf	Verhalten wie veröffentlicht	Korrigiertes Verhalten
LWG 230	C++98	Key musste nicht CopyConstructible sein (ein Schlüssel vom Typ Key konnte möglicherweise nicht konstruiert werden)	Key musste außerdem CopyConstructible sein
LWG 464	C++98	Der Zugriff auf eine konstante map über den Schlüssel war unpraktisch	at-Funktion bereitgestellt

Siehe auch

multimap	Sammlung von Schlüssel-Wert-Paaren, sortiert nach Schlüsseln (Klassenvorlage)
unordered_map (C++11)	Sammlung von Schlüssel-Wert-Paaren, gehasht nach Schlüsseln, Schlüssel sind eindeutig (Klassenvorlage)
flat_map (C++23)	passt zwei Container an, um eine Sammlung von Schlüssel-Wert-Paaren, sortiert nach eindeutigen Schlüsseln, bereitzustellen (Klassenvorlage)