std::flat_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::flat_map

Membertypen

Memberfunktionen

flat_map::flat_map flat_map::operator= Elementzugriff flat_map::at flat_map::operator[] Iteratoren flat_map::beginflat_map::cbegin flat_map::endflat_map::cend flat_map::rbeginflat_map::crbegin flat_map::rendflat_map::crend Suche flat_map::count flat_map::find flat_map::contains flat_map::equal_range    flat_map::lower_bound flat_map::upper_bound Kapazität flat_map::size flat_map::max_size flat_map::empty Modifizierer flat_map::clear flat_map::erase flat_map::swap flat_map::emplace flat_map::extract flat_map::replace flat_map::insert flat_map::insert_range flat_map::insert_or_assign flat_map::emplace_hint flat_map::try_emplace Observer flat_map::key_comp flat_map::keys flat_map::value_comp flat_map::values

Nicht-Member-Funktionen

operator==operator<=>         swap(std::flat_map) erase_if(std::flat_map)

Hilfsklassen

uses_allocator<std::flat_map>

Tags

sorted_unique       sorted_unique_t

Deduction Guides

 

Definiert in Header <flat_map>
template<     class Key,     class T,     class Compare = std::less<Key>,     class KeyContainer = std::vector<Key>,     class MappedContainer = std::vector<T> > class flat_map;		(seit C++23)

Der flat_map ist ein Container-Adapter, der die Funktionalität eines assoziativen Containers bereitstellt, der Schlüssel-Wert-Paare mit eindeutigen Schlüsseln enthält. Die Schlüssel werden mithilfe der Vergleichsfunktion Compare sortiert.

Die Klassenvorlage flat_map fungiert als Wrapper für die beiden zugrunde liegenden Container, die als Objekte vom Typ KeyContainer bzw. MappedContainer übergeben werden. Der erste Container ist sortiert und für jeden Schlüssel befindet sich der entsprechende Wert im zweiten Container am selben Index (Offset). Die Anzahl der Elemente in beiden Containern ist gleich.

Überall dort, wo die Standardbibliothek die Compare-Anforderungen verwendet, wird die Eindeutigkeit mithilfe der Äquivalenzrelation bestimmt. Informell gesagt, werden zwei Objekte a und b als äquivalent betrachtet, wenn keines kleiner als das andere ist: !comp(a, b) && !comp(b, a).

std::flat_map erfüllt die Anforderungen von Container, ReversibleContainer, optionalen Container-Anforderungen und alle Anforderungen von AssociativeContainer (einschließlich logarithmischer Suchkomplexität), mit Ausnahme von

• Anforderungen im Zusammenhang mit Knoten nicht zutreffen,
• die Anforderungen an die Iterator-Invalidierung unterschiedlich sind,
• die Komplexität von Einfüge- und Löschvorgängen linear ist.

Eine flat_map unterstützt die meisten Operationen von AssociativeContainer, die eindeutige Schlüssel verwenden.

Alle Memberfunktionen von std::flat_map sind constexpr: Es ist möglich, std::flat_map-Objekte in der Auswertung eines konstanten Ausdrucks zu erstellen und zu verwenden. std::flat_map-Objekte können jedoch im Allgemeinen nicht constexpr sein, da jeder dynamisch zugewiesene Speicher im selben konstanten Ausdruck freigegeben werden muss.

(seit C++26)

Template-Parameter

Key	-	Der Typ der Schlüssel. Das Programm ist ill-formed, wenn Key nicht derselbe Typ wie KeyContainer::value_type ist.
T	-	Der Typ der zugeordneten Werte. Das Programm ist ill-formed, wenn T nicht derselbe Typ wie MappedContainer::value_type ist.
Compare	-	Ein Compare-Typ, der eine strikte schwache Ordnung bereitstellt.
KeyContainer MappedContainer	-	Die Typen der zugrunde liegenden SequenceContainer zur Speicherung von Schlüsseln und zugeordneten Werten. Die Iteratoren solcher Container sollten LegacyRandomAccessIterator erfüllen oder random_access_iterator modellieren. Aufrufe ihrer Memberfunktionen size und max_size sollten keine Ausnahme auslösen. Die Standardcontainer std::vector und std::deque erfüllen diese Anforderungen.

Member-Typen

Typ	Definition
key_container_type	KeyContainer
mapped_container_type	MappedContainer
key_type	Key
mapped_type	T
value_type	std::pair<key_type, mapped_type>
key_compare	Compare
Referenz	std::pair<const key_type&, mapped_type&>
const_reference	std::pair<const key_type&, const mapped_type&>
size_type	std::size_t
difference_type	std::ptrdiff_t
iterator	implementierungsabhängiger LegacyInputIterator, ConstexprIterator(seit C++26) und random_access_iterator auf value_type
const_iterator	implementierungsabhängiger LegacyInputIterator, ConstexprIterator(seit C++26) und random_access_iterator auf const value_type
reverse_iterator	std::reverse_iterator<iterator>
const_reverse_iterator	std::reverse_iterator<const_iterator>
containers	Typ, der die zugrunde liegenden Container beschreibt struct containers {     key_container_type keys;     mapped_container_type values; };

Member-Klassen

value_compare

vergleicht Objekte vom Typ value_type (class)

Member-Objekte

Mitglied	Beschreibung
containers c (private)	die adaptierten Container ((exposition-only member object*)
key_compare compare (private)	das Vergleichsfunktions-Objekt ((exposition-only member object*)

Member-Funktionen

(Konstruktor)	konstruiert die flat_map (public member function)
(Destruktor) (implizit deklariert)	zerstört jedes Element des Container-Adapters (öffentliche Memberfunktion)
operator=	weist Werte dem Container-Adapter zu (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	gibt einen Iterator zum Anfang zurück (public member function)
endcend	gibt einen Iterator zum Ende zurück (public member function)
rbegincrbegin	gibt einen Reverse-Iterator zum Anfang zurück (public member function)
rendcrend	gibt einen Reverse-Iterator zum Ende zurück (public member function)
Kapazität
empty	prüft, ob der Container-Adapter 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
emplace	konstruiert Elemente direkt (in-place) (public member function)
emplace_hint	konstruiert Elemente "in place" unter Verwendung eines Hinweises (public member function)
try_emplace	fügt "in place" ein, wenn der Schlüssel nicht existiert, tut nichts, wenn der Schlüssel existiert (public member function)
insert	fügt Elemente ein (public member function)
insert_range	fügt einen Bereich von Elementen ein (public member function)
insert_or_assign	fügt ein Element ein oder weist einem vorhandenen Element einen Wert zu, falls der Schlüssel bereits existiert (public member function)
extract	extrahiert die zugrunde liegenden Container (public member function)
replace	ersetzt die zugrunde liegenden Container (public member function)
erase	entfernt Elemente (public member function)
swap	tauscht die Inhalte (public member function)
clear	leert den Inhalt (public member function)
Suche
find	sucht ein Element mit einem bestimmten Schlüssel (public member function)
zählt	gibt die Anzahl der Elemente zurück, die einem bestimmten Schlüssel entsprechen (public member function)
contains	prüft, ob der Container ein Element mit einem bestimmten Schlüssel enthält (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)
equal_range	gibt den Bereich von Elementen zurück, die einem bestimmten Schlüssel entsprechen (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)
keys	direkter Zugriff auf den zugrunde liegenden Schlüsselcontainer (public member function)
values	direkter Zugriff auf den zugrunde liegenden Wertecontainer (public member function)

Nicht-Member-Funktionen

operator==operator<=> (C++23)	vergleicht die Werte zweier flat_maps lexicographisch (function template)
std::swap(std::flat_map) (C++23)	spezialisiert den Algorithmus std::swap (function template)
erase_if(std::flat_map) (C++23)	entfernt alle Elemente, die bestimmte Kriterien erfüllen (function template)

Hilfsklassen

std::uses_allocator<std::flat_map> (C++23)

spezialisiert das std::uses_allocator Typ-Trait (Klassenvorlagenspezialisierung)

Tags

sorted_uniquesorted_unique_t (C++23)

zeigt an, dass Elemente eines Bereichs sortiert und eindeutig sind (Tag)

Hinweise

Die Member-Typen iterator und const_iterator können Aliase für denselben Typ sein. Das bedeutet, dass die Definition eines Paares von Funktionsüberladungen, die die beiden Typen als Parametertypen verwenden, die Ein-Definitionen-Regel (ODR) verletzen kann. Da iterator in const_iterator konvertierbar ist, funktioniert stattdessen eine einzelne Funktion mit einem const_iterator als Parametertyp.

Feature-Test-Makro	Wert	Std	Feature
__cpp_lib_flat_map	202207L	(C++23)	std::flat_map und std::flat_multimap
__cpp_lib_constexpr_containers	202502L	(C++26)	constexpr std::flat_map

Siehe auch

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