`map`-Klasse

Artikel
10/12/2023

Wird zum Speichern und Abrufen von Daten aus einer Auflistung verwendet, in der jedes Element ein Paar ist, das einen Datenwert und einen Sortierschlüssel aufweist. Der Wert des Schlüssels ist eindeutig und wird verwendet, zum automatischen Sortieren der Daten verwendet.

Der Wert eines Elements in einer Zuordnung kann direkt geändert werden. Der Schlüsselwert ist eine Konstante und kann nicht geändert werden. Stattdessen müssen die Schlüsselwerte, die alten Elementen zugeordnet sind, gelöscht und neue Schlüsselwerte für neue Elemente eingefügt werden.

Syntax

template <class Key,
    class Type,
    class Traits = less<Key>,
    class Allocator=allocator<pair <const Key, Type>>>
class map;

Parameter

Key
Der Schlüsseldatentyp, der in der mapDatei gespeichert werden soll.

Type
Der in map zu speichernde Elementdatentyp.

Traits
Der Typ, der ein Funktionsobjekt bereitstellt, das zwei Elementwerte als Sortierschlüssel vergleicht, um die relative Reihenfolge in der .map Dieses Argument ist optional, und das binäre Prädikat less<Key> ist der Standardwert.

In C++14 können Sie die heterogene Suche aktivieren, indem Sie das std::less<> Prädikat angeben, das keine Typparameter enthält. Weitere Informationen finden Sie unter heterogenes Nachschlagen in Associative Containers .

Allocator
Der Typ, der das gespeicherte Zuordnungsobjekt darstellt, das Details zum Belegen und Freigeben des Arbeitsspeichers der Zuordnung kapselt. Dieses Argument ist optional, und der Standardwert ist allocator<pair<const Key, Type> >.

Hinweise

Die map-Klasse der C++-Standardbibliothek ist:

Ein Container variabler Größe, der Elementwerte effizient auf Grundlage zugeordneter Schlüsselwerte abruft.
Umkehrbar, da bidirektionale Iteratoren für den Zugriff auf die Elemente bereitgestellt werden.
Sortiert, da die Elemente entsprechend einer angegebenen Vergleichsfunktion nach Schlüsselwerten sortiert werden.
Eindeutig. Eindeutig, da jedes der Elemente einen eindeutigen Schlüssel aufweisen muss.
Ein Paar-assoziativer Container, da sich die Elementdatenwerte von den Schlüsselwerten unterscheiden.
Eine Klassenvorlage, da die bereitgestellte Funktionalität generisch und unabhängig vom Element- oder Schlüsseltyp ist. Die für Elemente und Schlüssel verwendeten Datentypen werden in der Klassenvorlage zusammen mit der Vergleichsfunktion und der Zuweisung als Parameter angegeben.

Der von der Kartenklasse bereitgestellte Iterator ist ein bidirektionaler Iterator, aber die Und map Klassenmemberfunktionen verfügen über Versionen, die insert als Vorlagenparameter einen schwächeren Eingabe-Iterator verwenden, dessen Funktionalitätsanforderungen von der Klasse bidirektionaler Iteratoren weniger sind als diejenigen, die von der Klasse bidirektionaler Iteratoren garantiert werden. Die verschiedenen Iteratorkonzepte sind durch Verfeinerungen in ihrer Funktionen verknüpft. Jedes Iteratorkonzept weist einen eigenen Satz von Anforderungen auf, und damit einhergehenden Algorithmen müssen durch diese Anforderungen beschränkt werden. Ein Eingabeiterator kann dereferenziert werden, um auf ein Objekt zu verweisen und wird zum folgenden Iterator in der Sequenz erhöht.

Es wird empfohlen, dass Sie die Auswahl des Containertyps auf Grundlage der für die Anwendung erforderlichen Such- und Einfügeweise treffen. Assoziative Container sind auf Such-, Einfüge- und Entfernvorgänge optimiert. Die Memberfunktionen, die diese Vorgänge explizit unterstützen, führen sie in einem ungünstigsten Fall aus, der proportional zum Logarithmus der Anzahl der Elemente im Container ist. Das Einfügen von Elementen führt nicht dazu, dass Iteratoren ungültig werden, und durch das Entfernen von Elementen werden nur solche Iteratoren ungültig, die speziell auf die entfernten Elemente gezeigt haben.

Es wird empfohlen, die Zuordnung der ausgewählten assoziativen Container zu erstellen, wenn die Bedingungen zur Zuordnung der Werte mit Schlüssel von der Anwendung erfüllt werden. Ein Modell dieser Art von Struktur ist eine geordnete Liste eindeutig auftretender Schlüsselwörter, die Zeichenfolgewerte zugeordnet aufweisen, die Definitionen bereitstellen. Wenn ein Wort mehr als eine richtige Definition aufweist, sodass dieser Schlüssel nicht eindeutig ist, wäre eine Multimap der gewünschte Container. Wenn nur die Wortliste gespeichert wird, ist ein Satz der geeignete Container. Wenn mehrfaches Vorkommen der Wörter zulässig ist, ist eine Multimenge geeignet.

Die Zuordnung sortiert die Elemente, die es steuert, indem ein gespeichertes Funktionsobjekt vom Typ key_compareaufgerufen wird. Dieses gespeicherte Objekt ist eine Vergleichsfunktion, auf die durch Aufrufen der key_comp Methode zugegriffen wird. Im Allgemeinen werden zwei bestimmte Elemente verglichen, um festzustellen, ob ein Element kleiner als der andere ist oder ob sie gleichwertig sind. Obwohl alle Elemente verglichen werden, wird eine sortierte Sequenz antivalenter Elementen erstellt.

Hinweis

Die Vergleichsfunktion ist ein binäres Prädikat, das eine strenge schwache Sortierung im üblichen mathematischen Sinn erzeugt. Bei einem binären f(x,y)-Prädikat handelt es sich um ein Funktionsobjekt, das die zwei Argumentobjekte x und y aufweist sowie einen Rückgabewert von true oder false. Eine sortierung, die einem Satz auferlegt wird, ist eine strenge schwache Sortierung, wenn das binäre Prädikat irreflexiv, antisymmetrisch und transitiv ist und wenn die Äquivalenz transitiv ist, wobei zwei Objekte x und y definiert sind, um äquivalent zu sein, wenn sowohl f(x,y) als auch f(y,x) sind false. Wenn der stärkere Gleichheitszustand zwischen Schlüsseln die Äquivalenz ersetzt, erfolgt die Sortierung total (d. h., alle Elemente werden zueinander sortiert), und die verglichenen Schlüssel sind von den einander nicht mehr zu unterscheiden.

In C++14 können Sie heterogene Suche aktivieren, indem Sie das std::less<>std::greater<> Prädikat angeben, das keine Typparameter enthält. Weitere Informationen finden Sie unter heterogenes Nachschlagen in Associative Containers .

Member

Konstruktoren

Name	Beschreibung
`map`	Erstellt eine Liste einer bestimmten Größe bzw. mit Elementen eines bestimmten Werts oder mit einem bestimmten `allocator`-Element oder als vollständige bzw. teilweise Kopie einer anderen Zuordnung.

TypeDefs

Name	Beschreibung
`allocator_type`	Eine Typdefinition für die `allocator`-Klasse für das Zuordnungsobjekt.
`const_iterator`	Eine Typedef für einen bidirektionalen Iterator, der ein `const`-Element in der `map` lesen kann.
`const_pointer`	Eine Typdefinition für einen Zeiger auf ein `const`-Element in einer Zuordnung.
`const_reference`	Ein Typedef für einen Verweis auf ein `const` element, das in einer Zuordnung zum Lesen und Ausführen von `const` Vorgängen gespeichert ist.
`const_reverse_iterator`	Ein Typ, der einen bidirektionalen Iterator bereitstellt, der im `const`-Element jedes `map`-Element lesen kann.
`difference_type`	Ein Ganzzahltyp mit Vorzeichen für die Anzahl von Elementen einer Zuordnung in einem Bereich zwischen Elementen, auf die von Iteratoren gezeigt wird.
`iterator`	Eine Typedef für einen bidirektionalen Iterator, der ein beliebiges Element in einer Zuordnung lesen oder ändern kann.
`key_compare`	Eine Typedef für ein Funktionsobjekt, das zwei Sortierschlüssel vergleichen kann, um die relative Position von zwei Elementen in der `map` zu bestimmen.
`key_type`	Eine Typedef für den in jedem Element der Zuordnung gespeicherten Sortierschlüssel.
`mapped_type`	Eine Typedef für die in jedem Element einer Zuordnung gespeicherten Daten.
`pointer`	Eine Typdefinition für einen Zeiger auf ein `const`-Element in einer Zuordnung.
`reference`	Eine Typedef für einen Verweis auf ein in einer Zuordnung gespeichertes Element.
`reverse_iterator`	Eine Typdefinition für einen bidirektionalen Iterator, der ein beliebiges Element in einer reservierten Zuordnung lesen oder ändern kann.
`size_type`	Eine Ganzzahltypedef ohne Vorzeichen für die Anzahl von Elementen in einer Zuordnung.
`value_type`	Eine Typedef für den Typ des Objekts, der als Element in einer Zuordnung gespeichert wird.

Memberfunktionen

Memberfunktion	Beschreibung
`at`	Sucht ein Element mit dem angegebenen Schlüsselwert.
`begin`	Gibt einen Iterator zurück, der auf das erste Element in der `map` zeigt.
`cbegin`	Gibt einen Konst iterator zurück, der auf das erste Element in der .`map`
`cend`	Gibt einen konstanten "past-the-end"-Iterator zurück.
`clear`	Löscht alle Elemente einer `map` auf.
`contains`^C++20	Überprüfen Sie, ob ein Element mit dem angegebenen Schlüssel in der .`map`
`count`	Gibt die Anzahl von Elementen in einer Zuordnung zurück, deren Schlüssel dem in einem Parameter angegebenen Schlüssel entspricht.
`crbegin`	Gibt einen Konst iterator zurück, der auf das erste Element in einem umgekehrten `map`Element zeigt.
`crend`	Gibt einen Konst iterator zurück, der auf die Position nach dem letzten Element in einem umgekehrten `map`Element zeigt.
`emplace`	Fügt ein element ein, das in der `map`.
`emplace_hint`	Fügt ein element ein, das in der `map`Position erstellt wurde, mit einem Platzierungshinweis.
`empty`	Gibt zurück `true` , wenn eine `map` leer ist.
`end`	Gibt den "past-the-end"-Iterator zurück.
`equal_range`	Gibt ein Paar von Iteratoren zurück. Der erste Iterator im Paar zeigt auf das erste Element in `map` mit einem Schlüssel, der größer ist, als ein bestimmter Schlüssel. Der zweite Iterator im Paar zeigt auf das erste Element in `map` mit einem Schlüssel, die größer oder gleich dem Schlüssel ist.
`erase`	Entfernt ein Element oder eine Reihe von Elementen in einer Zuordnung aus den angegebenen Positionen.
`find`	Gibt einen Iterator zurück, der auf die Position eines Elements in einem `map` Element zeigt, das einen Schlüssel aufweist, der einem angegebenen Schlüssel entspricht.
`get_allocator`	Gibt eine Kopie des zum Erstellen der `allocator` verwendeten `map`-Objekts zurück.
`insert`	Fügt ein Element oder einen Elementbereich an einer angegebenen Position in das `map`-Element ein.
`key_comp`	Gibt eine Kopie des Vergleichsobjekts zurück, das zum Sortieren von Schlüsseln in einer `map`.
`lower_bound`	Gibt einen Iterator an das erste Element in einem `map` Element zurück, das einen Schlüsselwert aufweist, der gleich oder größer als der eines angegebenen Schlüssels ist.
`max_size`	Gibt die Maximallänge der `map` zurück.
`rbegin`	Gibt einen Iterator zurück, der auf das erste Element in einer umgekehrten `map` zeigt.
`rend`	Gibt einen Iterator zurück, der auf die Position nach dem letzten Element in einem umgekehrten `map`Element zeigt.
`size`	Gibt die Anzahl von Elementen in der `map` zurück.
`swap`	Tauscht die Elemente zweier Zuordnungen aus.
`upper_bound`	Gibt einen Iterator an das erste Element in einem `map` Element zurück, das einen Schlüsselwert aufweist, der größer als der eines angegebenen Schlüssels ist.
`value_comp`	Ruft eine Kopie des Vergleichsobjekts ab, das verwendet wird, um Elementwerte in einer `map` zu sortieren.

Operatoren

Name	Beschreibung
`operator[]`	Fügt ein Element in eine Zuordnung mit einem angegebenen Schlüsselwert ein.
`operator=`	Ersetzt die Elemente einer Zuordnung durch einer Kopie einer anderen Zuordnung.

`allocator_type`

Ein Typ, der die Zuweisungsklasse für das map-Objekt darstellt.

typedef Allocator allocator_type;

Beispiel

Ein Beispiel für get_allocator ein Beispiel, das verwendet wird, allocator_typefinden Sie unter .

`at`

Sucht ein Element mit einem angegebenen Schlüsselwert.

Type& at(const Key& key);

const Type& at(const Key& key) const;

Parameter

key
Der Schlüsselwert, das gesucht werden soll.

Rückgabewert

Ein Verweis auf den Datenwert des gefundenen Elements.

Hinweise

Wenn der Argumentschlüsselwert nicht gefunden wird, löst die Funktion ein Objekt der Klassenklasse out_of_rangeaus.

Beispiel

// map_at.cpp
// compile with: /EHsc
#include <map>
#include <iostream>

typedef std::map<char, int> Mymap;
int main()
    {
    Mymap c1;

    c1.insert(Mymap::value_type('a', 1));
    c1.insert(Mymap::value_type('b', 2));
    c1.insert(Mymap::value_type('c', 3));

// find and show elements
    std::cout << "c1.at('a') == " << c1.at('a') << std::endl;
    std::cout << "c1.at('b') == " << c1.at('b') << std::endl;
    std::cout << "c1.at('c') == " << c1.at('c') << std::endl;

    return (0);
    }

`begin`

Gibt ein Iterator zurück, der das erste Element im map-Element adressiert.

const_iterator begin() const;

iterator begin();

Rückgabewert

Ein bidirektionaler Iterator, der das erste Element in der oder an der Stelle angibt, an der map eine leere Karte erfolgreich war.

Beispiel

// map_begin.cpp
// compile with: /EHsc
#include <map>
#include <iostream>

int main( )
{
   using namespace std;
   map <int, int> m1;

   map <int, int> :: iterator m1_Iter;
   map <int, int> :: const_iterator m1_cIter;
   typedef pair <int, int> Int_Pair;

   m1.insert ( Int_Pair ( 0, 0 ) );
   m1.insert ( Int_Pair ( 1, 1 ) );
   m1.insert ( Int_Pair ( 2, 4 ) );

   m1_cIter = m1.begin ( );
   cout << "The first element of m1 is " << m1_cIter -> first << endl;

   m1_Iter = m1.begin ( );
   m1.erase ( m1_Iter );

   // The following 2 lines would err because the iterator is const
   // m1_cIter = m1.begin ( );
   // m1.erase ( m1_cIter );

   m1_cIter = m1.begin( );
   cout << "The first element of m1 is now " << m1_cIter -> first << endl;
}

The first element of m1 is 0
The first element of m1 is now 1

`cbegin`

Gibt einen const-Iterator zurück, der den Speicherort adressiert, der dem letzten Element eines Bereichs unmittelbar nachfolgt.

const_iterator cbegin() const;

Rückgabewert

Ein bidirektionaler const-Iterator, der das erste Element im Bereich oder die Position direkt hinter dem Ende eines leeren Bereichs adressiert (für einen leeren Bereich gilt cbegin() == cend()).

Hinweise

Mit dem Rückgabewert von cbegin, die Elemente im Bereich können nicht geändert werden.

Sie können diese Memberfunktion anstelle der begin()-Memberfunktion verwenden, um sicherzustellen, dass der Rückgabewert const_iterator ist. Normalerweise wird sie in Verbindung mit dem auto Typabzug Schlüsselwort (keyword) verwendet, wie im folgenden Beispiel gezeigt. Im folgenden Beispiel ist Container ein beliebiger änderbarer (Nicht-const-)Container, der begin() und cbegin() unterstützt.

auto i1 = Container.begin();
// i1 is Container<T>::iterator
auto i2 = Container.cbegin();

// i2 is Container<T>::const_iterator

`cend`

Gibt einen const-Iterator zurück, der den Speicherort adressiert, der dem letzten Element eines Bereichs unmittelbar nachfolgt.

const_iterator cend() const;

Rückgabewert

Ein bidirektionaler const-Access-Iterator, der auf eine Position unmittelbar nach dem Ende des Bereichs verweist.

Hinweise

cend wird verwendet, um zu testen, ob ein Iterator das Ende seines Bereichs übergeben hat.

Sie können diese Memberfunktion anstelle der end()-Memberfunktion verwenden, um sicherzustellen, dass der Rückgabewert const_iterator ist. Normalerweise wird sie in Verbindung mit dem auto Typabzug Schlüsselwort (keyword) verwendet, wie im folgenden Beispiel gezeigt. Im folgenden Beispiel ist Container ein beliebiger änderbarer (Nicht-const-)Container, der end() und cend() unterstützt.

auto i1 = Container.end();
// i1 is Container<T>::iterator
auto i2 = Container.cend();

// i2 is Container<T>::const_iterator

Der von cend zurückgegebene Wert darf nicht dereferenziert werden.

`clear`

Löscht alle Elemente einer Zuordnung auf.

void clear();

Beispiel

Im folgenden Beispiel wird die Verwendung der map::clear Memberfunktion veranschaulicht.

// map_clear.cpp
// compile with: /EHsc
#include <map>
#include <iostream>

int main()
{
    using namespace std;
    map<int, int> m1;
    map<int, int>::size_type i;
    typedef pair<int, int> Int_Pair;

    m1.insert(Int_Pair(1, 1));
    m1.insert(Int_Pair(2, 4));

    i = m1.size();
    cout << "The size of the map is initially "
         << i << "." << endl;

    m1.clear();
    i = m1.size();
    cout << "The size of the map after clearing is "
         << i << "." << endl;
}

The size of the map is initially 2.
The size of the map after clearing is 0.

`const_iterator`

Ein Typ, der einen bidirektionalen Iterator bereitstellt, der im const-Element ein map-Element lesen kann.

typedef implementation-defined const_iterator;

Hinweise

Ein Typ const_iterator kann nicht verwendet werden, um den Wert eines Elements zu ändern.

Die const_iterator durch die Zuordnung definierte Zuordnung verweist auf Elemente, die Objekte des value_typeTyps pair<constKey, Type>sind, deren erstes Element der Schlüssel für das Element ist und dessen zweites Element das zugeordnete Datum ist, das vom Element gehalten wird.

Verwenden Sie den ->-Operator, um einen const_iteratorcIter, der auf ein Element in einer Zuordnung zeigt, zu dereferenzieren.

Um auf den Wert des Schlüssels für das Element zuzugreifen, verwenden Sie cIter ->first, das entspricht (* cIter). first.

Um auf den Wert des zugeordneten Datums für das Element zuzugreifen, verwenden Sie cIter ->second, das entspricht (* cIter). second.

Beispiel

Ein Beispiel für begin ein Beispiel, das verwendet wird, const_iteratorfinden Sie unter .

`const_pointer`

Ein Typ, der einen Zeiger auf ein const Element in einer Karte bereitstellt.

typedef typename allocator_type::const_pointer const_pointer;

Hinweise

Ein Typ const_pointer kann nicht verwendet werden, um den Wert eines Elements zu ändern.

In den meisten Fällen sollte ein iterator Element für den Zugriff auf die Elemente in einem Kartenobjekt verwendet werden.

`const_reference`

Ein Typ, der einen Verweis auf ein const element bereitstellt, das in einer Karte zum Lesen und Ausführen von const Vorgängen gespeichert ist.

typedef typename allocator_type::const_reference const_reference;

Beispiel

// map_const_ref.cpp
// compile with: /EHsc
#include <map>
#include <iostream>

int main( )
{
   using namespace std;
   map <int, int> m1;
   typedef pair <int, int> Int_Pair;

   m1.insert ( Int_Pair ( 1, 10 ) );
   m1.insert ( Int_Pair ( 2, 20 ) );

   // Declare and initialize a const_reference &Ref1
   // to the key of the first element
   const int &Ref1 = ( m1.begin( ) -> first );

   // The following line would cause an error as the
   // non-const_reference can't be used to access the key
   // int &Ref1 = ( m1.begin( ) -> first );

   cout << "The key of first element in the map is "
        << Ref1 << "." << endl;

   // Declare and initialize a reference &Ref2
   // to the data value of the first element
   int &Ref2 = ( m1.begin( ) -> second );

   cout << "The data value of first element in the map is "
        << Ref2 << "." << endl;
}

The key of first element in the map is 1.
The data value of first element in the map is 10.

`const_reverse_iterator`

Ein Typ, der einen bidirektionalen Iterator bereitstellt, der im const-Element jedes map-Element lesen kann.

typedef std::reverse_iterator<const_iterator> const_reverse_iterator;

Hinweise

Ein Typ const_reverse_iterator kann den Wert eines Elements nicht ändern und wird verwendet, um die Karte umgekehrt zu durchlaufen.

Die const_reverse_iterator durch die Zuordnung definierte Zuordnung verweist auf Elemente, die Objekte des value_typeTyps pair<const Key, Type>sind, deren erstes Element der Schlüssel für das Element ist und dessen zweites Element das zugeordnete Datum ist, das vom Element gehalten wird.

Verwenden Sie den ->-Operator, um einen const_reverse_iterator crIter, der auf ein Element in einer Zuordnung zeigt, zu dereferenzieren.

Um auf den Wert des Schlüssels für das Element zuzugreifen, verwenden Sie crIter "->first", das entspricht (* crIter).first.

Um auf den Wert des zugeordneten Datums für das Element zuzugreifen, verwenden Sie crIter "->second", das entspricht (* crIter).first.

Beispiel

Ein Beispiel für rend das Deklarieren und Verwenden const_reverse_iteratorfinden Sie im Beispiel.

`count`

Gibt die Anzahl von Elementen in einer Zuordnung zurück, dessen Schlüssel dem von einem Parameter angegebenen Schlüssel entspricht.

size_type count(const Key& key) const;

Parameter

key
Der Schlüsselwert der aus der Zuordnung zu entfernenden Elemente.

Rückgabewert

1, wenn die Zuordnung ein Element enthält, dessen Sortierungsschlüssel dem Parameterschlüssel entspricht; 0, wenn die Zuordnung kein Element mit einem übereinstimmenden Schlüssel enthält.

Hinweise

Die Memberfunktion ermöglicht die Rückgabe der Anzahl von Elementen x im Bereich

[ lower_bound(key), upper_bound(key)

0 oder 1 für eine Zuordnung, was einem eindeutigen assoziativen Container entspricht.

Beispiel

Im folgenden Beispiel wird die Verwendung der map::count Memberfunktion veranschaulicht.

// map_count.cpp
// compile with: /EHsc
#include <map>
#include <iostream>

int main()
{
    using namespace std;
    map<int, int> m1;
    map<int, int>::size_type i;
    typedef pair<int, int> Int_Pair;

    m1.insert(Int_Pair(1, 1));
    m1.insert(Int_Pair(2, 1));
    m1.insert(Int_Pair(1, 4));
    m1.insert(Int_Pair(2, 1));

    // Keys must be unique in map, so duplicates are ignored
    i = m1.count(1);
    cout << "The number of elements in m1 with a sort key of 1 is: "
         << i << "." << endl;

    i = m1.count(2);
    cout << "The number of elements in m1 with a sort key of 2 is: "
         << i << "." << endl;

    i = m1.count(3);
    cout << "The number of elements in m1 with a sort key of 3 is: "
         << i << "." << endl;
}

The number of elements in m1 with a sort key of 1 is: 1.
The number of elements in m1 with a sort key of 2 is: 1.
The number of elements in m1 with a sort key of 3 is: 0.

`contains`

Überprüft, ob ein Element mit dem angegebenen Schlüssel in der map.

bool contains(const Key& key) const;
template<class K> bool contains(const K& key) const;

Parameter

K
Der Typ des Schlüssels.

key
Der Schlüsselwert des Elements, nach dem gesucht werden soll.

Rückgabewert

true wenn das Element im Container gefunden wird; false Andernfalls.

Hinweise

contains() ist neu in C++20. Geben Sie die /std:c++20 Compileroption an, um sie zu verwenden.

template<class K> bool contains(const K& key) const nimmt nur an der Überladungsauflösung teil, wenn key_compare dies transparent ist. Weitere Informationen finden Sie unter heterogene Suche in assoziativen Containern .

Beispiel

// Requires /std:c++20 or /std:c++latest
#include <map>
#include <string>
#include <iostream>
#include <functional>

int main()
{
    std::map<int, bool> m = {{0, true},{1, false}};

    std::cout << std::boolalpha; // so booleans show as 'true' or 'false'
    std::cout << m.contains(1) << '\n';
    std::cout << m.contains(2) << '\n';

    // call template function
    std::map<std::string, int, std::less<>> m2 = {{"ten", 10}, {"twenty", 20}, {"thirty", 30}};
    std::cout << m2.contains("ten");

    return 0;
}

true
false
true

`crbegin`

Gibt einen const-Iterator zurück, der das erste Element in einer umgekehrten Zuordnung adressiert.

const_reverse_iterator crbegin() const;

Rückgabewert

Ein umgekehrter bidirektionaler Iterator, der das erste Element in einer umgekehrten map Oder adressiert, was das letzte Element in der unreversierten map.

Hinweise

crbegin wird mit einem umgekehrten map verwendet, genau wie begin bei einem map.

Mit dem Rückgabewert des crbeginObjekts kann das map Objekt nicht geändert werden.

Mit crbegin kann ein map rückwärts durchlaufen werden.

Beispiel

// map_crbegin.cpp
// compile with: /EHsc
#include <map>
#include <iostream>

int main( )
{
   using namespace std;
   map <int, int> m1;

   map <int, int> :: const_reverse_iterator m1_crIter;
   typedef pair <int, int> Int_Pair;

   m1.insert ( Int_Pair ( 1, 10 ) );
   m1.insert ( Int_Pair ( 2, 20 ) );
   m1.insert ( Int_Pair ( 3, 30 ) );

   m1_crIter = m1.crbegin( );
   cout << "The first element of the reversed map m1 is "
        << m1_crIter -> first << "." << endl;
}

The first element of the reversed map m1 is 3.

`crend`

Gibt einen const-Iterator zurück, der den Speicherort adressiert, der auf das letzte Element einer umgekehrten Zuordnung folgt.

const_reverse_iterator crend() const;

Rückgabewert

Ein umgekehrter bidirektionaler Iterator, der die Position angibt, an der das letzte Element in einem umgekehrten map Element ausgeführt wurde (die Position, die dem ersten Element in der unreversierten mapSeite vorausging).

Hinweise

crend wird mit einer umgekehrten Karte verwendet, genau wie end bei einer map.

Mit dem Rückgabewert des crendObjekts kann das map Objekt nicht geändert werden.

crend kann verwendet werden, um zu testen, ob das Ende der map von einem umgekehrten Iterator erreicht wurde.

Der von crend zurückgegebene Wert darf nicht dereferenziert werden.

Beispiel

// map_crend.cpp
// compile with: /EHsc
#include <map>
#include <iostream>

int main( )
{
   using namespace std;
   map <int, int> m1;

   map <int, int> :: const_reverse_iterator m1_crIter;
   typedef pair <int, int> Int_Pair;

   m1.insert ( Int_Pair ( 1, 10 ) );
   m1.insert ( Int_Pair ( 2, 20 ) );
   m1.insert ( Int_Pair ( 3, 30 ) );

   m1_crIter = m1.crend( );
   m1_crIter--;
   cout << "The last element of the reversed map m1 is "
        << m1_crIter -> first << "." << endl;
}

The last element of the reversed map m1 is 1.

`difference_type`

Ein Ganzzahltyp mit Vorzeichen, der dazu verwendet werden kann, die Anzahl von Elementen einer Zuordnung in einem Bereich zwischen Elementen darzustellen, auf die von Iteratoren gezeigt wird.

typedef allocator_type::difference_type difference_type;

Hinweise

difference_type ist der Typ, der beim Subtrahieren oder Inkrementieren über Iteratoren des Containers zurückgegeben wird. difference_type wird normalerweise verwendet, um die Anzahl von Elementen im Bereich (first, last) zwischen den Iteratoren first und last darzustellen. Dazu gehört das Element, auf das durch first gezeigt wird und der Bereich von Elementen bis zu (aber nicht einschließlich) dem Element, auf das durch last gezeigt wird.

Obwohl difference_type für alle Iteratoren verfügbar ist, die die Anforderungen eines Eingabe-Iterators erfüllen, einschließlich der Klasse bidirektionaler Iteratoren, die von umkehrbaren Containern wie Set unterstützt werden, wird subtraktion zwischen Iteratoren nur von Iteratoren mit zufälligem Zugriff unterstützt, die von einem Zufallszugriffscontainer wie Vektor bereitgestellt werden.

Beispiel

// map_diff_type.cpp
// compile with: /EHsc
#include <iostream>
#include <map>
#include <algorithm>

int main( )
{
   using namespace std;
   map <int, int> m1;
   typedef pair <int, int> Int_Pair;

   m1.insert ( Int_Pair ( 2, 20 ) );
   m1.insert ( Int_Pair ( 1, 10 ) );
   m1.insert ( Int_Pair ( 3, 20 ) );
   m1.insert ( Int_Pair ( 2, 30 ) );

   map <int, int>::iterator m1_Iter, m1_bIter, m1_eIter;
   m1_bIter = m1.begin( );
   m1_eIter = m1.end( );

   // Count the number of elements in a map
   map <int, int>::difference_type  df_count = 1;
   m1_Iter = m1.begin( );
   while ( m1_Iter != m1_eIter)
   {
      df_count++;
      m1_Iter++;
   }

   cout << "The number of elements in the map m1 is: "
        << df_count << "." << endl;
}

The number of elements in the map m1 is: 4.

`emplace`

Es wird ein Element eingefügt, das vor Ort in eine Zuordnung konstruiert wird (keine Kopieren- oder Verschiebevorgänge werden ausgeführt).

template <class... Args>
pair<iterator, bool>
emplace(
    Args&&... args);

Parameter

args
Die Argumente, die weitergeleitet werden, um ein Element zu konstruieren, das in die Zuordnung eingefügt werden soll, es sei denn, es enthält bereits ein Element, dessen Wert gleichwertig sortiert ist.

Rückgabewert

A pair whose bool component is true if an insertion was made, and false if the map already contained an element of equivalent value in the order. Die Iteratorkomponente des Rückgabewertpaars zeigt auf das neu eingefügten Element, wenn die bool-Komponente "true" lautet, oder auf das vorhandene Element, wenn die bool-Komponente "false" lautet.

Um auf die Iteratorkomponente eines pairpr-Elements zuzugreifen, verwenden Sie pr.first. Um es zu dereferenzieren, verwenden Sie *pr.first. Um auf die bool-Komponente zuzugreifen, verwenden Sie pr.second. Eine Beispiel finden Sie unter Beispielcode weiter unten in diesem Artikel.

Hinweise

Durch diese Funktion werden keine Iteratoren oder Verweise ungültig.

Wenn eine Ausnahme ausgelöst wird, wird der Containerstatus während der Emplacement nicht geändert.

Das value_type Element ist ein Paar, sodass der Wert eines Elements ein geordnetes Paar mit der ersten Komponente ist, die dem Schlüsselwert und der zweiten Komponente entspricht dem Datenwert des Elements.

Beispiel

// map_emplace.cpp
// compile with: /EHsc
#include <map>
#include <string>
#include <iostream>

using namespace std;

template <typename M> void print(const M& m) {
    cout << m.size() << " elements: ";

    for (const auto& p : m) {
        cout << "(" << p.first << ", " << p.second << ") ";
    }

    cout << endl;
}

int main()
{
    map<int, string> m1;

    auto ret = m1.emplace(10, "ten");

    if (!ret.second){
        auto pr = *ret.first;
        cout << "Emplace failed, element with key 10 already exists."
            << endl << "  The existing element is (" << pr.first << ", " << pr.second << ")"
            << endl;
        cout << "map not modified" << endl;
    }
    else{
        cout << "map modified, now contains ";
        print(m1);
    }
    cout << endl;

    ret = m1.emplace(10, "one zero");

    if (!ret.second){
        auto pr = *ret.first;
        cout << "Emplace failed, element with key 10 already exists."
            << endl << "  The existing element is (" << pr.first << ", " << pr.second << ")"
            << endl;
    }
    else{
        cout << "map modified, now contains ";
        print(m1);
    }
    cout << endl;
}

`emplace_hint`

Fügt ein Element mit einem Platzierungshinweis ein, das vor Ort erstellt wird (Es werden keine Kopier- oder Verschiebevorgänge ausgeführt).

template <class... Args>
iterator emplace_hint(
    const_iterator where,
    Args&&... args);

Parameter

args
Die Argumente, die weitergeleitet werden, um ein Element zu konstruieren, das in die Zuordnung eingefügt werden soll, es sei denn, die Zuordnung enthält dieses Element oder allgemeiner, es sei denn, es enthält bereits ein Element, dessen Schlüssel gleichwertig sortiert ist.

where
Die Position, an dem mit der Suche nach dem richtigen Einfügepunkt begonnen wird. (Wenn dieser Punkt unmittelbar vor dem Ort liegt, kann die Einfügung in amortisierter Konstantenzeit anstelle der logarithmischen Zeit auftreten.)

Rückgabewert

Ein Iterator zum neu eingefügten Element.

Wenn die Einfügung fehlerhaft war, da das Element bereits vorhanden ist, wird ein Iterator an das vorhandene Element mit dem Schlüssel zurückgegeben.

Hinweise

Durch diese Funktion werden keine Iteratoren oder Verweise ungültig.

Wenn eine Ausnahme ausgelöst wird, wird der Containerstatus während der Emplacement nicht geändert.

Beispiel

// map_emplace.cpp
// compile with: /EHsc
#include <map>
#include <string>
#include <iostream>

using namespace std;

template <typename M> void print(const M& m) {
    cout << m.size() << " elements: " << endl;

    for (const auto& p : m) {
        cout << "(" << p.first <<  "," << p.second << ") ";
    }

    cout << endl;
}

int main()
{
    map<string, string> m1;

    // Emplace some test data
    m1.emplace("Anna", "Accounting");
    m1.emplace("Bob", "Accounting");
    m1.emplace("Carmine", "Engineering");

    cout << "map starting data: ";
    print(m1);
    cout << endl;

    // Emplace with hint
    // m1.end() should be the "next" element after this emplacement
    m1.emplace_hint(m1.end(), "Doug", "Engineering");

    cout << "map modified, now contains ";
    print(m1);
    cout << endl;
}

`empty`

Prüft, ob eine Zuordnung leer ist.

bool empty() const;

Rückgabewert

true wenn die Karte leer ist; false wenn die Karte nicht in Denkhaft ist.

Beispiel

// map_empty.cpp
// compile with: /EHsc
#include <map>
#include <iostream>

int main( )
{
   using namespace std;
   map <int, int> m1, m2;

   typedef pair <int, int> Int_Pair;
   m1.insert ( Int_Pair ( 1, 1 ) );

   if ( m1.empty( ) )
      cout << "The map m1 is empty." << endl;
   else
      cout << "The map m1 is not empty." << endl;

   if ( m2.empty( ) )
      cout << "The map m2 is empty." << endl;
   else
      cout << "The map m2 is not empty." << endl;
}

The map m1 is not empty.
The map m2 is empty.

`end`

Gibt den "past-the-end"-Iterator zurück.

const_iterator end() const;

iterator end();

Rückgabewert

Der "past-the-end"-Iterator. Wenn die Zuordnung leer ist, dann gilt map::end() == map::begin().

Hinweise

end wird verwendet, um zu testen, ob ein Iterator das Ende seiner Karte bestanden hat.

Der von end zurückgegebene Wert darf nicht dereferenziert werden.

Ein Codebeispiel finden Sie unter map::find.

`equal_range`

Gibt ein Iteratorpaar zurück, das den lower_bound Schlüssel und den upper_bound Schlüssel darstellt.

pair <const_iterator, const_iterator> equal_range (const Key& key) const;

pair <iterator, iterator> equal_range (const Key& key);

Parameter

key
Der Argumentschlüsselwert, der mit dem Sortierschlüssel eines Elements aus der zu durchsuchenden Zuordnung verglichen wird.

Rückgabewert

Sie können auf den ersten Iterator eines von einer Memberfunktion zurückgegebenen Paars pr zugreifen, indem Sie pr. verwenden Sie zum Ableiten der unteren Iterator *( pr. zuerst). Sie können auf den zweiten Iterator eines von einer Memberfunktion zurückgegebenen Paars pr zugreifen, indem Sie pr. zweitens und zum Ableiten der oberen Begrenzungs iterator verwenden Sie *( pr. second).

Beispiel

// map_equal_range.cpp
// compile with: /EHsc
#include <map>
#include <iostream>

int main( )
{
   using namespace std;
   typedef map <int, int, less<int> > IntMap;
   IntMap m1;
   map <int, int> :: const_iterator m1_RcIter;
   typedef pair <int, int> Int_Pair;

   m1.insert ( Int_Pair ( 1, 10 ) );
   m1.insert ( Int_Pair ( 2, 20 ) );
   m1.insert ( Int_Pair ( 3, 30 ) );

   pair <IntMap::const_iterator, IntMap::const_iterator> p1, p2;
   p1 = m1.equal_range( 2 );

   cout << "The lower bound of the element with "
        << "a key of 2 in the map m1 is: "
        << p1.first -> second << "." << endl;

   cout << "The upper bound of the element with "
        << "a key of 2 in the map m1 is: "
        << p1.second -> second << "." << endl;

   // Compare the upper_bound called directly
   m1_RcIter = m1.upper_bound( 2 );

   cout << "A direct call of upper_bound( 2 ) gives "
        << m1_RcIter -> second << "," << endl
        << "matching the 2nd element of the pair"
        << " returned by equal_range( 2 )." << endl;

   p2 = m1.equal_range( 4 );

   // If no match is found for the key,
   // both elements of the pair return end( )
   if ( ( p2.first == m1.end( ) ) && ( p2.second == m1.end( ) ) )
      cout << "The map m1 doesn't have an element "
           << "with a key less than 40." << endl;
   else
      cout << "The element of map m1 with a key >= 40 is: "
           << p2.first -> first << "." << endl;
}

The lower bound of the element with a key of 2 in the map m1 is: 20.
The upper bound of the element with a key of 2 in the map m1 is: 30.
A direct call of upper_bound( 2 ) gives 30,
matching the 2nd element of the pair returned by equal_range( 2 ).
The map m1 doesn't have an element with a key less than 40.

`erase`

Es wird ein Element oder ein Bereich von Elementen in einer Zuordnung von angegebenen Speicherorten entfernt oder es werden die einem angegebenen Schlüssel entsprechenden Elemente entfernt.

iterator erase(
    const_iterator Where);

iterator erase(
    const_iterator First,
    const_iterator Last);

size_type erase(
    const key_type& Key);

Parameter

Where
Die Position des zu entfernenden Elements.

First
Die Position des ersten zu entfernenden Elements.

Last
Die Position direkt hinter dem letzten zu entfernenden Element.

Key
Der Schlüsselwert der zu entfernenden Elemente.

Rückgabewert

Bei den ersten beiden Memberfunktionen ist es ein bidirektionaler Iterator, der das erste über die entfernten Elemente hinaus verbliebe Element festlegt, oder ein Element, das das Ende der Zuordnung darstellt, wenn kein solches Element vorhanden ist.

Für die dritte Memberfunktion wird die Anzahl der von der Zuordnung entfernten Elemente zurück gegeben.

Beispiel

// map_erase.cpp
// compile with: /EHsc
#include <map>
#include <string>
#include <iostream>
#include <iterator> // next() and prev() helper functions
#include <utility>  // make_pair()

using namespace std;

using mymap = map<int, string>;

void printmap(const mymap& m) {
    for (const auto& elem : m) {
        cout << " [" << elem.first << ", " << elem.second << "]";
    }
    cout << endl << "size() == " << m.size() << endl << endl;
}

int main()
{
    mymap m1;

    // Fill in some data to test with, one at a time
    m1.insert(make_pair(1, "A"));
    m1.insert(make_pair(2, "B"));
    m1.insert(make_pair(3, "C"));
    m1.insert(make_pair(4, "D"));
    m1.insert(make_pair(5, "E"));

    cout << "Starting data of map m1 is:" << endl;
    printmap(m1);
    // The 1st member function removes an element at a given position
    m1.erase(next(m1.begin()));
    cout << "After the 2nd element is deleted, the map m1 is:" << endl;
    printmap(m1);

    // Fill in some data to test with, one at a time, using an initializer list
    mymap m2
    {
        { 10, "Bob" },
        { 11, "Rob" },
        { 12, "Robert" },
        { 13, "Bert" },
        { 14, "Bobby" }
    };

    cout << "Starting data of map m2 is:" << endl;
    printmap(m2);
    // The 2nd member function removes elements
    // in the range [First, Last)
    m2.erase(next(m2.begin()), prev(m2.end()));
    cout << "After the middle elements are deleted, the map m2 is:" << endl;
    printmap(m2);

    mymap m3;

    // Fill in some data to test with, one at a time, using emplace
    m3.emplace(1, "red");
    m3.emplace(2, "yellow");
    m3.emplace(3, "blue");
    m3.emplace(4, "green");
    m3.emplace(5, "orange");
    m3.emplace(6, "purple");
    m3.emplace(7, "pink");

    cout << "Starting data of map m3 is:" << endl;
    printmap(m3);
    // The 3rd member function removes elements with a given Key
    mymap::size_type count = m3.erase(2);
    // The 3rd member function also returns the number of elements removed
    cout << "The number of elements removed from m3 is: " << count << "." << endl;
    cout << "After the element with a key of 2 is deleted, the map m3 is:" << endl;
    printmap(m3);
}

`find`

Gibt einen Iterator zurück, der auf den Speicherort eines Elements in einer Zuordnung verweist, der einen Schlüssel gleich einem angegebenen Schlüssel aufweist.

iterator find(const Key& key);

const_iterator find(const Key& key) const;

Parameter

key
Der Schlüsselwert, der mit dem Sortierschlüssel eines Elements aus der zu durchsuchenden Zuordnung übereinstimmt.

Rückgabewert

Ein Iterator, der auf die Position eines Elements mit einem angegebenen Schlüssel verweist, oder die Position, an der das letzte Element in der map (map::end()) ausgeführt wird, wenn keine Übereinstimmung für den Schlüssel gefunden wird.

Hinweise

Die Memberfunktion gibt einen Iterator zurück, der sich auf ein Element in derEn map Sortierschlüssel bezieht, das dem Argumentschlüssel unter einem binären Prädikat entspricht, das eine Sortierung basierend auf einer Vergleichbarkeitsbeziehung auslöst.

Wenn der Rückgabewert find eines const_iteratorObjekts zugewiesen ist, kann das Kartenobjekt nicht geändert werden. Wenn der Rückgabewert find eines iteratorObjekts zugewiesen ist, kann das Kartenobjekt geändert werden.

Beispiel

// compile with: /EHsc /W4 /MTd
#include <map>
#include <iostream>
#include <vector>
#include <string>
#include <utility>  // make_pair()

using namespace std;

template <typename A, typename B> void print_elem(const pair<A, B>& p) {
    cout << "(" << p.first << ", " << p.second << ") ";
}

template <typename T> void print_collection(const T& t) {
    cout << t.size() << " elements: ";

    for (const auto& p : t) {
        print_elem(p);
    }
    cout << endl;
}

template <typename C, class T> void findit(const C& c, T val) {
    cout << "Trying find() on value " << val << endl;
    auto result = c.find(val);
    if (result != c.end()) {
        cout << "Element found: "; print_elem(*result); cout << endl;
    } else {
        cout << "Element not found." << endl;
    }
}

int main()
{
    map<int, string> m1({ { 40, "Zr" }, { 45, "Rh" } });
    cout << "The starting map m1 is (key, value):" << endl;
    print_collection(m1);

    vector<pair<int, string>> v;
    v.push_back(make_pair(43, "Tc"));
    v.push_back(make_pair(41, "Nb"));
    v.push_back(make_pair(46, "Pd"));
    v.push_back(make_pair(42, "Mo"));
    v.push_back(make_pair(44, "Ru"));
    v.push_back(make_pair(44, "Ru")); // attempt a duplicate

    cout << "Inserting the following vector data into m1:" << endl;
    print_collection(v);

    m1.insert(v.begin(), v.end());

    cout << "The modified map m1 is (key, value):" << endl;
    print_collection(m1);
    cout << endl;
    findit(m1, 45);
    findit(m1, 6);
}

`get_allocator`

Gibt eine Kopie des allocator-Objekts zurück, das zum Erstellen der Zuordnung verwendet wird.

allocator_type get_allocator() const;

Rückgabewert

Die Zuweisung, die von der Zuordnung verwendet wird.

Hinweise

Zuweisungen für die map-Klasse geben an, wie die Klasse einen Speicher verwaltet. Für die meisten Programmieranforderungen reichen die standardmäßigen allocator-Objekte mit Container-Klassen der C++-Standardbibliothek aus. Schreiben und Verwenden Ihrer eigener Zuweisungsklasse ist ein C++ -Thema für Fortgeschrittene.

Beispiel

// map_get_allocator.cpp
// compile with: /EHsc
#include <map>
#include <iostream>

int main( )
{
   using namespace std;
   map <int, int>::allocator_type m1_Alloc;
   map <int, int>::allocator_type m2_Alloc;
   map <int, double>::allocator_type m3_Alloc;
   map <int, int>::allocator_type m4_Alloc;

   // The following lines declare objects
   // that use the default allocator.
   map <int, int> m1;
   map <int, int, allocator<int> > m2;
   map <int, double, allocator<double> > m3;

   m1_Alloc = m1.get_allocator( );
   m2_Alloc = m2.get_allocator( );
   m3_Alloc = m3.get_allocator( );

   cout << "The number of integers that can be allocated\n"
        << "before free memory is exhausted: "
        << m2.max_size( ) << ".\n" << endl;

   cout << "The number of doubles that can be allocated\n"
        << "before free memory is exhausted: "
        << m3.max_size( ) <<  ".\n" << endl;

   // The following line creates a map m4
   // with the allocator of map m1.
   map <int, int> m4( less<int>( ), m1_Alloc );

   m4_Alloc = m4.get_allocator( );

   // Two allocators are interchangeable if
   // storage allocated from each can be
   // deallocated with the other
   if( m1_Alloc == m4_Alloc )
   {
      cout << "The allocators are interchangeable." << endl;
   }
   else
   {
      cout << "The allocators are not interchangeable." << endl;
   }
}

`insert`

Fügt ein Element oder einen Elementbereich in eine Zuordnung ein.

// (1) single element
pair<iterator, bool> insert(
    const value_type& Val);

// (2) single element, perfect forwarded
template <class ValTy>
pair<iterator, bool>
insert(
    ValTy&& Val);

// (3) single element with hint
iterator insert(
    const_iterator Where,
    const value_type& Val);

// (4) single element, perfect forwarded, with hint
template <class ValTy>
iterator insert(
    const_iterator Where,
    ValTy&& Val);

// (5) range
template <class InputIterator>
void insert(
    InputIterator First,
    InputIterator Last);

// (6) initializer list
void insert(
    initializer_list<value_type>
IList);

Parameter

Val
Der Wert eines Elements, das in die Zuordnung eingefügt werden soll, es sei denn, es enthält bereits ein Element, dessen Schlüssel äquivalent sortiert ist.

Where
Die Position, an dem mit der Suche nach dem richtigen Einfügepunkt begonnen wird. (Wenn dieser Punkt Where direkt vorausgeht, kann die Einfügung in amortisierter konstanter Zeit anstelle von logarithmischer Zeit eintreten.)

ValTy
Vorlagenparameter, der den Argumenttyp angibt, den die Zuordnung verwenden kann, um ein Element von value_typeund perfekte Weiterleitungen Val als Argument zu erstellen.

First
Die Position des ersten zu kopierenden Elements.

Last
Die Position direkt über den letzten zu kopierenden Elements.

InputIterator
Vorlagenfunktionsargument, das den Anforderungen eines Eingabe-Iterators entspricht, der auf Elemente eines Typs verweist, die zum Erstellen value_type von Objekten verwendet werden können.

IList
Die initializer_list Elemente, von denen die Elemente kopiert werden sollen.

Rückgabewert

Die Einzelelementfunktionen (1) und (2) geben eine pair Komponente zurück, deren bool Komponente wahr ist, wenn eine Einfügung vorgenommen wurde, und "false", wenn die Zuordnung bereits ein Element enthielt, dessen Schlüssel einen entsprechenden Wert in der Reihenfolge aufweist. Die Iteratorkomponente des Rückgabewertpaars zeigt auf das neu eingefügten Element, wenn die bool-Komponente "true" lautet, oder auf das vorhandene Element, wenn die bool-Komponente "false" lautet.

Die Einzelelement-Memberfunktionen mit Hinweis (3) und (4) geben einen Iterator zurück, der auf die Position zeigt, an der das neue Element in die Zuordnung eingefügt wurde, oder, falls ein Element mit einem entsprechenden Schlüssel bereits vorhanden ist, auf das vorhandene Element.

Hinweise

Durch diese Funktion werden keine Iteratoren, Zeiger oder Verweise ungültig.

Wenn eine Ausnahme ausgelöst wird, wird der Containerstatus während der Einfügung nur eines Elements nicht geändert. Wird beim Einfügen mehrerer Elementen eine Ausnahme ausgelöst, wird der Container in einem nicht angegebenen doch gültigen Zustand belassen.

Um auf die Iteratorkomponente eines pairpr-Elements zuzugreifen, das von den Einzelelement-Memberfunktionen zurückgegeben wird, wird pr.first verwendet. Um den Iterator im zurückgegebenen Paar zu dereferenzieren, verwenden Sie *pr.first. Damit erhalten Sie ein Element. Um auf die bool-Komponente zuzugreifen, verwenden Sie pr.second. Eine Beispiel finden Sie unter Beispielcode weiter unten in diesem Artikel.

Der value_type Container ist ein Typedef, der zum Container gehört, und für die Zuordnung map<K, V>::value_type ist pair<const K, V>. Der Wert eines Elements ist ein sortiertes Paar, in dem die erste Komponente gleich dem Schlüsselwert und die zweite Komponente gleich dem Datenwert des Elements ist.

Die Bereichsmemberfunktion (5) fügt die Sequenz von Elementwerten in eine Zuordnung ein, die jedem Element entspricht, das von einem Iterator im Bereich [First, Last) adressiert wird. Daher wird Last nicht eingefügt. Die Containermemberfunktion end() bezieht sich auf die Position direkt hinter dem letzten Element im Container. Z. B versucht die Anweisung m.insert(v.begin(), v.end()); alle Elemente von v in m einzufügen. Nur Elemente, die eindeutige Werte im Bereich aufweisen werden eingefügt. Duplikate werden ignoriert. Um zu betrachten welche Elemente abgelehnt werden, verwenden Sie die Einzelelementversionen von insert.

Die Initialisierungslistenelementfunktion (6) verwendet ein initializer_list Element zum Kopieren von Elementen in die Karte.

Informationen zum Einfügen eines direkt erstellten Elements , d. h. es werden keine Kopier- oder Verschiebungsvorgänge ausgeführt – siehe map::emplace und map::emplace_hint.

Beispiel

// map_insert.cpp
// compile with: /EHsc
#include <map>
#include <iostream>
#include <string>
#include <vector>
#include <utility>  // make_pair()

using namespace std;

template <typename M> void print(const M& m) {
    cout << m.size() << " elements: ";

    for (const auto& p : m) {
        cout << "(" << p.first << ", " << p.second << ") ";
    }

    cout << endl;
}

int main()
{
    // insert single values
    map<int, int> m1;
    // call insert(const value_type&) version
    m1.insert({ 1, 10 });
    // call insert(ValTy&&) version
    m1.insert(make_pair(2, 20));

    cout << "The original key and mapped values of m1 are:" << endl;
    print(m1);

    // intentionally attempt a duplicate, single element
    auto ret = m1.insert(make_pair(1, 111));
    if (!ret.second){
        auto pr = *ret.first;
        cout << "Insert failed, element with key value 1 already exists."
            << endl << "  The existing element is (" << pr.first << ", " << pr.second << ")"
            << endl;
    }
    else{
        cout << "The modified key and mapped values of m1 are:" << endl;
        print(m1);
    }
    cout << endl;

    // single element, with hint
    m1.insert(m1.end(), make_pair(3, 30));
    cout << "The modified key and mapped values of m1 are:" << endl;
    print(m1);
    cout << endl;

    // The templatized version inserting a jumbled range
    map<int, int> m2;
    vector<pair<int, int>> v;
    v.push_back(make_pair(43, 294));
    v.push_back(make_pair(41, 262));
    v.push_back(make_pair(45, 330));
    v.push_back(make_pair(42, 277));
    v.push_back(make_pair(44, 311));

    cout << "Inserting the following vector data into m2:" << endl;
    print(v);

    m2.insert(v.begin(), v.end());

    cout << "The modified key and mapped values of m2 are:" << endl;
    print(m2);
    cout << endl;

    // The templatized versions move-constructing elements
    map<int, string>  m3;
    pair<int, string> ip1(475, "blue"), ip2(510, "green");

    // single element
    m3.insert(move(ip1));
    cout << "After the first move insertion, m3 contains:" << endl;
    print(m3);

    // single element with hint
    m3.insert(m3.end(), move(ip2));
    cout << "After the second move insertion, m3 contains:" << endl;
    print(m3);
    cout << endl;

    map<int, int> m4;
    // Insert the elements from an initializer_list
    m4.insert({ { 4, 44 }, { 2, 22 }, { 3, 33 }, { 1, 11 }, { 5, 55 } });
    cout << "After initializer_list insertion, m4 contains:" << endl;
    print(m4);
    cout << endl;
}

`iterator`

Ein Typ, der einen bidirektionalen Iterator bereitstellt, mit dem jedes Element in einer Zuordnung gelesen oder geändert werden kann.

typedef implementation-defined iterator;

Hinweise

Der von der Zuordnung definierte Iterator verweist auf Elemente, die value_typeObjekte des Typs pair<const Key, Type>sind, deren erstes Element der Schlüssel für das Element ist und dessen zweites Element das zugeordnete Datum ist, das vom Element gehalten wird.

Verwenden Sie den -> Operator, um einen Iterator Iter abzuleiten, der auf ein Element in einer Karte zeigt.

Um auf den Wert des Schlüssels für das Element zuzugreifen, verwenden Sie Iter->firstdie Entsprechende .(*Iter).first Um auf den Wert des zugeordneten Datums für das Element zuzugreifen, verwenden Sie Iter->seconddies , was entspricht (*Iter).second.

Beispiel

Ein Beispiel für begin das Deklarieren und Verwenden iteratorfinden Sie im Beispiel.

`key_comp`

Ruft eine Kopie des Vergleichsobjekts ab, das zum Sortieren der Schlüssel in einer Zuordnung verwendet wird.

key_compare key_comp() const;

Rückgabewert

Gibt das Funktionsobjekt zurück, das eine Zuordnung zum Sortieren ihrer Elemente verwendet.

Hinweise

Das gespeicherte Objekt definiert die Memberfunktion

bool operator(const Key& left, const Key& right);

gibt zurück true , wenn left sie vorangestellt ist und nicht in der Sortierreihenfolge gleich ist right .

Beispiel

// map_key_comp.cpp
// compile with: /EHsc
#include <map>
#include <iostream>

int main( )
{
   using namespace std;

   map <int, int, less<int> > m1;
   map <int, int, less<int> >::key_compare kc1 = m1.key_comp( ) ;
   bool result1 = kc1( 2, 3 ) ;
   if( result1 == true )
   {
      cout << "kc1( 2,3 ) returns value of true, "
           << "where kc1 is the function object of m1."
           << endl;
   }
   else
   {
      cout << "kc1( 2,3 ) returns value of false "
           << "where kc1 is the function object of m1."
           << endl;
   }

   map <int, int, greater<int> > m2;
   map <int, int, greater<int> >::key_compare kc2 = m2.key_comp( );
   bool result2 = kc2( 2, 3 ) ;
   if( result2 == true )
   {
      cout << "kc2( 2,3 ) returns value of true, "
           << "where kc2 is the function object of m2."
           << endl;
   }
   else
   {
      cout << "kc2( 2,3 ) returns value of false, "
           << "where kc2 is the function object of m2."
           << endl;
   }
}

kc1( 2,3 ) returns value of true, where kc1 is the function object of m1.
kc2( 2,3 ) returns value of false, where kc2 is the function object of m2.

`key_compare`

Eine Typ, der ein Funktionsobjekt bereitstellt, das zwei Sortierschlüssel vergleichen kann, um die relative Position von zwei Elementen im map-Element zu bestimmen.

typedef Traits key_compare;

Hinweise

key_compare ist ein Synonym für den Vorlagenparameter Traits.

Weitere Informationen Traitsfinden Sie im map Thema "Klasse ".

Beispiel

Ein Beispiel für key_comp das Deklarieren und Verwenden key_comparefinden Sie im Beispiel.

`key_type`

Eine Typ, der den in jedem Element der Zuordnung gespeicherten Sortierschlüssel beschreibt.

typedef Key key_type;

Hinweise

key_type ist ein Synonym für den Vorlagenparameter Key.

Weitere Informationen Keyfinden Sie im Abschnitt "Hinweise " des map Themas "Klasse ".

Beispiel

Ein Beispiel für value_type das Deklarieren und Verwenden key_typefinden Sie im Beispiel.

`lower_bound`

Gibt einen Iterator zum ersten Element in einer Zuordnung mit einem Schlüsselwert zurück, der gleich oder größer ist, als ein angegebener Schlüssel.

iterator lower_bound(const Key& key);

const_iterator lower_bound(const Key& key) const;

Parameter

key
Der Argumentschlüsselwert, der mit dem Sortierschlüssel eines Elements aus der zu durchsuchenden Zuordnung verglichen wird.

Rückgabewert

Eine iterator oder const_iterator die die Position eines Elements in einer Karte adressiert, die mit einem Schlüssel gleich oder größer als dem Argumentschlüssel ist, oder die die Position angibt, an der das letzte Element im map Letzten gefunden wird, wenn keine Übereinstimmung für den Schlüssel gefunden wird.

Wenn der Rückgabewert lower_bound eines const_iteratorObjekts zugewiesen ist, kann das Kartenobjekt nicht geändert werden. Wenn der Rückgabewert lower_bound eines iteratorObjekts zugewiesen ist, kann das Kartenobjekt geändert werden.

Beispiel

// map_lower_bound.cpp
// compile with: /EHsc
#include <map>
#include <iostream>

int main( )
{
   using namespace std;
   map <int, int> m1;
   map <int, int> :: const_iterator m1_AcIter, m1_RcIter;
   typedef pair <int, int> Int_Pair;

   m1.insert ( Int_Pair ( 1, 10 ) );
   m1.insert ( Int_Pair ( 2, 20 ) );
   m1.insert ( Int_Pair ( 3, 30 ) );

   m1_RcIter = m1.lower_bound( 2 );
   cout << "The first element of map m1 with a key of 2 is: "
        << m1_RcIter -> second << "." << endl;

   // If no match is found for this key, end( ) is returned
   m1_RcIter = m1. lower_bound ( 4 );

   if ( m1_RcIter == m1.end( ) )
      cout << "The map m1 doesn't have an element "
           << "with a key of 4." << endl;
   else
      cout << "The element of map m1 with a key of 4 is: "
           << m1_RcIter -> second << "." << endl;

   // The element at a specific location in the map can be found
   // using a dereferenced iterator addressing the location
   m1_AcIter = m1.end( );
   m1_AcIter--;
   m1_RcIter = m1. lower_bound ( m1_AcIter -> first );
   cout << "The element of m1 with a key matching "
        << "that of the last element is: "
        << m1_RcIter -> second << "." << endl;
}

The first element of map m1 with a key of 2 is: 20.
The map m1 doesn't have an element with a key of 4.
The element of m1 with a key matching that of the last element is: 30.

`map`

Erstellt eine Zuordnung, die leer oder die Kopie einer vollständigen anderen Zuordnung oder eines Teils davon ist.

map();

explicit map(
    const Traits& Comp);

map(
    const Traits& Comp,
    const Allocator& Al);

map(
    const map& Right);

map(
    map&& Right);

map(
    initializer_list<value_type> IList);

map(
    initializer_list<value_type> IList,
    const Traits& Comp);

map(
    initializer_list<value_type> IList,
    const Traits& Comp,
    const Allocator& Allocator);

template <class InputIterator>
map(
    InputIterator First,
    InputIterator Last);

template <class InputIterator>
map(
    InputIterator First,
    InputIterator Last,
    const Traits& Comp);

template <class InputIterator>
map(
    InputIterator First,
    InputIterator Last,
    const Traits& Comp,
    const Allocator& Al);

Parameter

Al
Die für dieses Zuordnungsobjekt zu verwendende Speicherzuweisungsklasse, dessen Standard Allocator ist.

Comp
Die Vergleichsfunktion vom Typ const Traits, die verwendet wird, um die Elemente in map, deren Standard hash_compare ist, zu sortieren.

Right
Die Zuordnung, deren Kopie der erstellte Satz sein soll.

First
Die Position des ersten Elements in dem zu kopierenden Elementbereich.

Last
Die Position des ersten Elements nach dem zu kopierenden Elementbereich.

IList
Das initializer_list-Element, von dem die Elemente kopiert werden sollen.

Hinweise

Alle Konstruktoren speichern einen Typ von Allocator-Objekt, der den Speicher für die Karte verwaltet und die später durch Aufrufen get_allocatorzurückgegeben werden kann. Der Zuweisungsparameter wird häufig aus den Klassendeklarationen und den Vorverarbeitungsmakros weggelassen, die zum Ersetzen alternativer Zuweisungen verwendet werden.

Alle Konstruktoren initialisieren die Zuordnung.

Alle Konstruktoren speichern ein Funktionsobjekt vom Typ Traits, das verwendet wird, um eine Reihenfolge zwischen den Schlüsseln der Karte herzustellen und die später durch Aufrufen key_compzurückgegeben werden können.

Die ersten drei Konstruktoren geben eine leere anfängliche Zuordnung an, die zweite, die den Typ der Vergleichsfunktion (Comp) angibt, die zum Herstellen der Reihenfolge der Elemente verwendet werden soll, und der dritte explizit den zu verwendenden Allocatortyp (Al) angeben. Mit dem Schlüsselwort explicit werden bestimmte Arten automatischer Typumwandlung unterdrückt.

Der vierte Konstruktor gibt eine Kopie der Right-Zuordnung an.

Der fünfte Konstruktor gibt eine Kopie der Zuordnung an, indem Right verschoben wird.

Die Konstruktoren 6., 7. und 8. verwenden eine initializer_list , aus der die Member kopiert werden.

Mit den nächsten drei Konstruktoren wird der [First, Last)-Bereich, einer Zuordnung kopiert, wobei sich die Explizitheit bei Angabe des Typs der Vergleichsfunktion der Klasse Traits und "Allocator" erhöht.

Beispiel

// map_map.cpp
// compile with: /EHsc
#include <map>
#include <iostream>

int main()
{
    using namespace std;
    typedef pair <int, int> Int_Pair;
    map <int, int>::iterator m1_Iter, m3_Iter, m4_Iter, m5_Iter, m6_Iter, m7_Iter;
    map <int, int, less<int> >::iterator m2_Iter;

    // Create an empty map m0 of key type integer
    map <int, int> m0;

    // Create an empty map m1 with the key comparison
    // function of less than, then insert 4 elements
    map <int, int, less<int> > m1;
    m1.insert(Int_Pair(1, 10));
    m1.insert(Int_Pair(2, 20));
    m1.insert(Int_Pair(3, 30));
    m1.insert(Int_Pair(4, 40));

    // Create an empty map m2 with the key comparison
    // function of greater than, then insert 2 elements
    map <int, int, less<int> > m2;
    m2.insert(Int_Pair(1, 10));
    m2.insert(Int_Pair(2, 20));

    // Create a map m3 with the
    // allocator of map m1
    map <int, int>::allocator_type m1_Alloc;
    m1_Alloc = m1.get_allocator();
    map <int, int> m3(less<int>(), m1_Alloc);
    m3.insert(Int_Pair(3, 30));

    // Create a copy, map m4, of map m1
    map <int, int> m4(m1);

    // Create a map m5 by copying the range m1[ first,  last)
    map <int, int>::const_iterator m1_bcIter, m1_ecIter;
    m1_bcIter = m1.begin();
    m1_ecIter = m1.begin();
    m1_ecIter++;
    m1_ecIter++;
    map <int, int> m5(m1_bcIter, m1_ecIter);

    // Create a map m6 by copying the range m4[ first,  last)
    // and with the allocator of map m2
    map <int, int>::allocator_type m2_Alloc;
    m2_Alloc = m2.get_allocator();
    map <int, int> m6(m4.begin(), ++m4.begin(), less<int>(), m2_Alloc);

    cout << "m1 =";
    for (auto i : m1)
        cout << i.first << " " << i.second << ", ";
    cout << endl;

    cout << "m2 =";
    for(auto i : m2)
        cout << i.first << " " << i.second << ", ";
    cout << endl;

    cout << "m3 =";
    for (auto i : m3)
        cout << i.first << " " << i.second << ", ";
    cout << endl;

    cout << "m4 =";
    for (auto i : m4)
        cout << i.first << " " << i.second << ", ";
    cout << endl;

    cout << "m5 =";
    for (auto i : m5)
        cout << i.first << " " << i.second << ", ";
    cout << endl;

    cout << "m6 =";
    for (auto i : m6)
        cout << i.first << " " << i.second << ", ";
    cout << endl;

    // Create a map m7 by moving m5
    cout << "m7 =";
    map<int, int> m7(move(m5));
    for (auto i : m7)
        cout << i.first << " " << i.second << ", ";
    cout << endl;

    // Create a map m8 by copying in an initializer_list
    map<int, int> m8{ { { 1, 1 }, { 2, 2 }, { 3, 3 }, { 4, 4 } } };
    cout << "m8: = ";
    for (auto i : m8)
        cout << i.first << " " << i.second << ", ";
    cout << endl;

    // Create a map m9 with an initializer_list and a comparator
    map<int, int> m9({ { 5, 5 }, { 6, 6 }, { 7, 7 }, { 8, 8 } }, less<int>());
    cout << "m9: = ";
    for (auto i : m9)
        cout << i.first << " " << i.second << ", ";
    cout << endl;

    // Create a map m10 with an initializer_list, a comparator, and an allocator
    map<int, int> m10({ { 9, 9 }, { 10, 10 }, { 11, 11 }, { 12, 12 } }, less<int>(), m9.get_allocator());
    cout << "m10: = ";
    for (auto i : m10)
        cout << i.first << " " << i.second << ", ";
    cout << endl;
}

`mapped_type`

Ein Typ, der die in einer Zuordnung gespeicherten Daten darstellt.

typedef Type mapped_type;

Hinweise

Der Typ mapped_type ist ein Synonym für den Type-Vorlagenparameter der Klasse.

Weitere Informationen Typefinden Sie im map Thema "Klasse ".

Beispiel

Ein Beispiel für value_type das Deklarieren und Verwenden mapped_typefinden Sie im Beispiel.

`max_size`

Gibt die Maximallänge der Zuordnung zurück.

size_type max_size() const;

Rückgabewert

Die mögliche Maximallänge der Zuordnung.

Beispiel

// map_max_size.cpp
// compile with: /EHsc
#include <map>
#include <iostream>

int main( )
{
   using namespace std;
   map <int, int> m1;
   map <int, int> :: size_type i;

   i = m1.max_size( );
   cout << "The maximum possible length "
        << "of the map is " << i << "."
        << endl << "(Magnitude is machine specific.)";
}

`operator[]`

Fügt ein Element in eine Zuordnung mit einem angegebenen Schlüsselwert ein.

Type& operator[](const Key& key);

Type& operator[](Key&& key);

Parameter

key
Der Schlüsselwert des elements, das eingefügt werden soll.

Rückgabewert

Ein Verweis auf den Datenwert des eingefügten Elements.

Hinweise

Wenn der Argumentschlüsselwert nicht gefunden wird, wird er zusammen mit dem Standardwert des Datentyps eingefügt.

operator[] kann zum Einfügen von Elementen in eine m-Zuordnung mit m[key] = DataValue; verwendet werden, wobei DataValue der Wert des mapped_type des Elements mit einem Schlüsselwert von key ist.

Wenn operator[] zum Einfügen von Elementen verwendet wird, gibt der zurückgegebene Verweis nicht an, ob eine Einfügung ein bereits vorhandenes Element ändert oder ein neues erstellt. Die Memberfunktionen find und insert können verwendet werden, um zu bestimmen, ob ein Element mit einer angegebenen Taste bereits vor der Einfügung vorhanden ist.

Beispiel

// map_op_insert.cpp
// compile with: /EHsc
#include <map>
#include <iostream>
#include <string>

int main( )
{
   using namespace std;
   typedef pair <const int, int> cInt2Int;
   map <int, int> m1;
   map <int, int> :: iterator pIter;

   // Insert a data value of 10 with a key of 1
   // into a map using the operator[] member function
   m1[ 1 ] = 10;

   // Compare other ways to insert objects into a map
   m1.insert ( map <int, int> :: value_type ( 2, 20 ) );
   m1.insert ( cInt2Int ( 3, 30 ) );

   cout  << "The keys of the mapped elements are:";
   for ( pIter = m1.begin( ) ; pIter != m1.end( ) ; pIter++ )
      cout << " " << pIter -> first;
   cout << "." << endl;

   cout  << "The values of the mapped elements are:";
   for ( pIter = m1.begin( ) ; pIter != m1.end( ) ; pIter++ )
      cout << " " << pIter -> second;
   cout << "." << endl;

   // If the key already exists, operator[]
   // changes the value of the datum in the element
   m1[ 2 ] = 40;

   // operator[] will also insert the value of the data
   // type's default constructor if the value is unspecified
   m1[5];

   cout  << "The keys of the mapped elements are now:";
   for ( pIter = m1.begin( ) ; pIter != m1.end( ) ; pIter++ )
      cout << " " << pIter -> first;
   cout << "." << endl;

   cout  << "The values of the mapped elements are now:";
   for ( pIter = m1.begin( ) ; pIter != m1.end( ) ; pIter++ )
      cout << " " << pIter -> second;
   cout << "." << endl;

// insert by moving key
    map<string, int> c2;
    string str("abc");
    cout << "c2[move(str)] == " << c2[move(str)] << endl;
    cout << "c2["abc"] == " << c2["abc"] << endl;

    return (0);
}

The keys of the mapped elements are: 1 2 3.
The values of the mapped elements are: 10 20 30.
The keys of the mapped elements are now: 1 2 3 5.
The values of the mapped elements are now: 10 40 30 0.
c2[move(str)] == 0
c2["abc"] == 1

`operator=`

Ersetzt die Elemente einer Zuordnung durch einer Kopie einer anderen Zuordnung.

map& operator=(const map& right);
map& operator=(map&& right);

Parameter

right
Das map kopierte In das map.

Hinweise

Nachdem ein vorhandenes Element in einem map gelöscht wurde, kopiert oder verschiebt operator= den Inhalt von right in die Zuordnung.

Beispiel

// map_operator_as.cpp
// compile with: /EHsc
#include <map>
#include <iostream>

int main( )
   {
   using namespace std;
   map<int, int> v1, v2, v3;
   map<int, int>::iterator iter;

   v1.insert(pair<int, int>(1, 10));

   cout << "v1 = " ;
   for (iter = v1.begin(); iter != v1.end(); iter++)
      cout << iter->second << " ";
   cout << endl;

   v2 = v1;
   cout << "v2 = ";
   for (iter = v2.begin(); iter != v2.end(); iter++)
      cout << iter->second << " ";
   cout << endl;

// move v1 into v2
   v2.clear();
   v2 = move(v1);
   cout << "v2 = ";
   for (iter = v2.begin(); iter != v2.end(); iter++)
      cout << iter->second << " ";
   cout << endl;
   }

`pointer`

Ein Typ, der einen Zeiger auf ein Element in einer Zuordnung bereitstellt.

typedef typename allocator_type::pointer pointer;

Hinweise

Ein Typ pointer kann verwendet werden, um den Wert eines Elements zu ändern.

In den meisten Fällen sollte ein iterator Element für den Zugriff auf die Elemente in einem Kartenobjekt verwendet werden.

rbegin

Gibt einen Iterator zurück, der das erste Element in einer umgekehrten Zuordnung adressiert.

const_reverse_iterator rbegin() const;

reverse_iterator rbegin();

Rückgabewert

Ein umgekehrter bidirektionaler Iterator, der auf das erste Element in einer umgekehrten map oder auf das letzte Element der vormals nicht umgekehrten map verweist.

Hinweise

rbegin wird mit einer umgekehrten Karte wie begin bei einer Karte verwendet.

Wenn der Rückgabewert rbegin eines const_reverse_iteratorObjekts zugewiesen ist, kann das Kartenobjekt nicht geändert werden. Wenn der Rückgabewert von rbegin einem reverse_iterator zugewiesen wird, kann das map-Objekt geändert werden.

rbegin kann verwendet werden, um eine Zuordnung rückwärts zu durchlaufen.

Beispiel

// map_rbegin.cpp
// compile with: /EHsc
#include <map>
#include <iostream>

int main( )
{
   using namespace std;
   map <int, int> m1;

   map <int, int> :: iterator m1_Iter;
   map <int, int> :: reverse_iterator m1_rIter;
   map <int, int> :: const_reverse_iterator m1_crIter;
   typedef pair <int, int> Int_Pair;

   m1.insert ( Int_Pair ( 1, 10 ) );
   m1.insert ( Int_Pair ( 2, 20 ) );
   m1.insert ( Int_Pair ( 3, 30 ) );

   m1_rIter = m1.rbegin( );
   cout << "The first element of the reversed map m1 is "
        << m1_rIter -> first << "." << endl;

   // begin can be used to start an iteration
   // through a map in a forward order
   cout << "The map is: ";
   for ( m1_Iter = m1.begin( ) ; m1_Iter != m1.end( ); m1_Iter++)
      cout << m1_Iter -> first << " ";
      cout << "." << endl;

   // rbegin can be used to start an iteration
   // through a map in a reverse order
   cout << "The reversed map is: ";
   for ( m1_rIter = m1.rbegin( ) ; m1_rIter != m1.rend( ); m1_rIter++)
      cout << m1_rIter -> first << " ";
      cout << "." << endl;

   // A map element can be erased by dereferencing to its key
   m1_rIter = m1.rbegin( );
   m1.erase ( m1_rIter -> first );

   m1_rIter = m1.rbegin( );
   cout << "After the erasure, the first element "
        << "in the reversed map is "
        << m1_rIter -> first << "." << endl;
}

The first element of the reversed map m1 is 3.
The map is: 1 2 3 .
The reversed map is: 3 2 1 .
After the erasure, the first element in the reversed map is 2.

`reference`

Ein Typ, der einen Verweis auf ein in einer Zuordnung gespeichertes Element bereitstellt.

typedef typename allocator_type::reference reference;

Beispiel

// map_reference.cpp
// compile with: /EHsc
#include <map>
#include <iostream>

int main( )
{
   using namespace std;
   map <int, int> m1;
   typedef pair <int, int> Int_Pair;

   m1.insert ( Int_Pair ( 1, 10 ) );
   m1.insert ( Int_Pair ( 2, 20 ) );

   // Declare and initialize a const_reference &Ref1
   // to the key of the first element
   const int &Ref1 = ( m1.begin( ) -> first );

   // The following line would cause an error because the
   // non-const_reference can't be used to access the key
   // int &Ref1 = ( m1.begin( ) -> first );

   cout << "The key of first element in the map is "
        << Ref1 << "." << endl;

   // Declare and initialize a reference &Ref2
   // to the data value of the first element
   int &Ref2 = ( m1.begin( ) -> second );

   cout << "The data value of first element in the map is "
        << Ref2 << "." << endl;

   //The non-const_reference can be used to modify the
   //data value of the first element
   Ref2 = Ref2 + 5;
   cout << "The modified data value of first element is "
        << Ref2 << "." << endl;
}

The key of first element in the map is 1.
The data value of first element in the map is 10.
The modified data value of first element is 15.

`rend`

Gibt einen Iterator zurück, der den Speicherort adressiert, der auf das letzte Element einer umgekehrten Zuordnung folgt.

const_reverse_iterator rend() const;

reverse_iterator rend();

Rückgabewert

Ein umgekehrter bidirektionaler Iterator, der den Standort anspricht, der dem letzten Element in einer umgekehrten Zuordnung nachfolgt (der Speicherort, der dem ersten Element in der nicht umgekehrten Zuordnung vorangegangen war).

Hinweise

rend wird mit einer umgekehrten Karte wie end bei einer Karte verwendet.

Wenn der Rückgabewert rend eines const_reverse_iteratorObjekts zugewiesen ist, kann das Kartenobjekt nicht geändert werden. Wenn der Rückgabewert von rend einem reverse_iterator zugewiesen wird, kann das map-Objekt geändert werden.

rend kann verwendet werden, um zu testen, ob das Ende der Zuordnung von einem umgekehrten Iterator erreicht wurde.

Der von rend zurückgegebene Wert darf nicht dereferenziert werden.

Beispiel

// map_rend.cpp
// compile with: /EHsc
#include <map>
#include <iostream>

int main( )
{
   using namespace std;
   map <int, int> m1;

   map <int, int> :: iterator m1_Iter;
   map <int, int> :: reverse_iterator m1_rIter;
   map <int, int> :: const_reverse_iterator m1_crIter;
   typedef pair <int, int> Int_Pair;

   m1.insert ( Int_Pair ( 1, 10 ) );
   m1.insert ( Int_Pair ( 2, 20 ) );
   m1.insert ( Int_Pair ( 3, 30 ) );

   m1_rIter = m1.rend( );
   m1_rIter--;
   cout << "The last element of the reversed map m1 is "
        << m1_rIter -> first << "." << endl;

   // begin can be used to start an iteration
   // through a map in a forward order
   cout << "The map is: ";
   for ( m1_Iter = m1.begin( ) ; m1_Iter != m1.end( ); m1_Iter++)
      cout << m1_Iter -> first << " ";
      cout << "." << endl;

   // rbegin can be used to start an iteration
   // through a map in a reverse order
   cout << "The reversed map is: ";
   for ( m1_rIter = m1.rbegin( ) ; m1_rIter != m1.rend( ); m1_rIter++)
      cout << m1_rIter -> first << " ";
      cout << "." << endl;

   // A map element can be erased by dereferencing to its key
   m1_rIter = --m1.rend( );
   m1.erase ( m1_rIter -> first );

   m1_rIter = m1.rend( );
   m1_rIter--;
   cout << "After the erasure, the last element "
        << "in the reversed map is "
        << m1_rIter -> first << "." << endl;
}

The last element of the reversed map m1 is 1.
The map is: 1 2 3 .
The reversed map is: 3 2 1 .
After the erasure, the last element in the reversed map is 2.

`reverse_iterator`

Ein Typ, der einen bidirektionalen Iterator bereitstellt, mit dem ein Element in einer umgekehrten Zuordnung gelesen oder geändert werden kann.

typedef std::reverse_iterator<iterator> reverse_iterator;

Hinweise

Ein Typ reverse_iterator kann den Wert eines Elements nicht ändern und wird verwendet, um die Karte umgekehrt zu durchlaufen.

Die reverse_iterator durch die Zuordnung definierte Zuordnung verweist auf Elemente, die Objekte des value_typeTyps pair<const Key, Type>sind, deren erstes Element der Schlüssel für das Element ist und dessen zweites Element das zugeordnete Datum ist, das vom Element gehalten wird.

Verwenden Sie den -> Operator, um einen reverse_iteratorrIter abzuleiten, der auf ein Element in einer Karte zeigt.

Verwenden Sie rIter ->first, um auf den Wert des Schlüssels für das Element zuzugreifen, das dem (* rIterentspricht). first. Um auf den Wert des zugeordneten Datums für das Element zuzugreifen, verwenden Sie rIter ->sekunde, was dem (* rIterentspricht). first.

Beispiel

Ein Beispiel für rbegin das Deklarieren und Verwenden reverse_iteratorfinden Sie im Beispiel.

`size`

Gibt die Anzahl von Elementen in der map zurück.

size_type size() const;

Rückgabewert

Die aktuelle Länge der Zuordnung.

Beispiel

Im folgenden Beispiel wird die Verwendung der map::size Memberfunktion veranschaulicht.

// map_size.cpp
// compile with: /EHsc
#include <map>
#include <iostream>

int main()
{
    using namespace std;
    map<int, int> m1, m2;
    map<int, int>::size_type i;
    typedef pair<int, int> Int_Pair;

    m1.insert(Int_Pair(1, 1));
    i = m1.size();
    cout << "The map length is " << i << "." << endl;

    m1.insert(Int_Pair(2, 4));
    i = m1.size();
    cout << "The map length is now " << i << "." << endl;
}

The map length is 1.
The map length is now 2.

`size_type`

Ein Ganzzahltyp ohne Vorzeichen, der die Anzahl von Elementen in einer Zuordnung darstellen kann.

typedef typename allocator_type::size_type size_type;

Beispiel

Ein Beispiel für size das Deklarieren und Verwenden size_typefinden Sie im Beispiel.

swap

Tauscht die Elemente zweier Zuordnungen aus.

void swap(
    map<Key, Type, Traits, Allocator>& right);

Parameter

right
Das map-Argument, das die Elemente bereitstellt, mit denen die Zielzuordnung getauscht werden soll.

Hinweise

Die Memberfunktion macht keine Verweise, Zeiger oder Iteratoren ungültig, die Elemente in den zwei Zuordnungen bezeichnen, deren Elemente ausgetauscht werden sollen.

Beispiel

// map_swap.cpp
// compile with: /EHsc
#include <map>
#include <iostream>

int main( )
{
   using namespace std;
   map <int, int> m1, m2, m3;
   map <int, int>::iterator m1_Iter;
   typedef pair <int, int> Int_Pair;

   m1.insert ( Int_Pair ( 1, 10 ) );
   m1.insert ( Int_Pair ( 2, 20 ) );
   m1.insert ( Int_Pair ( 3, 30 ) );
   m2.insert ( Int_Pair ( 10, 100 ) );
   m2.insert ( Int_Pair ( 20, 200 ) );
   m3.insert ( Int_Pair ( 30, 300 ) );

   cout << "The original map m1 is:";
   for ( m1_Iter = m1.begin( ); m1_Iter != m1.end( ); m1_Iter++ )
      cout << " " << m1_Iter -> second;
   cout   << "." << endl;

   // This is the member function version of swap
   //m2 is said to be the argument map; m1 the target map
   m1.swap( m2 );

   cout << "After swapping with m2, map m1 is:";
   for ( m1_Iter = m1.begin( ); m1_Iter != m1.end( ); m1_Iter++ )
      cout << " " << m1_Iter -> second;
   cout  << "." << endl;

   // This is the specialized template version of swap
   swap( m1, m3 );

   cout << "After swapping with m3, map m1 is:";
   for ( m1_Iter = m1.begin( ); m1_Iter != m1.end( ); m1_Iter++ )
      cout << " " << m1_Iter -> second;
   cout   << "." << endl;
}

The original map m1 is: 10 20 30.
After swapping with m2, map m1 is: 100 200.
After swapping with m3, map m1 is: 300.

`upper_bound`

Gibt einen Iterator zum ersten Element in einer Zuordnung mit einem Schlüsselwert zurück, der größer ist als ein angegebener Schlüssel.

iterator upper_bound(const Key& key);

const_iterator upper_bound(const Key& key) const;

Parameter

key
Der Argumentschlüsselwert, der mit dem Sortierschlüsselwert eines Elements aus der zu durchsuchenden Zuordnung verglichen wird.

Rückgabewert

Eine iterator oder const_iterator die die Position eines Elements in einer Karte adressiert, die einen Schlüssel enthält, der größer als der Argumentschlüssel ist, oder die die Position angibt, an der das letzte Element im letzten Element ausgeführt map wird, wenn keine Übereinstimmung für den Schlüssel gefunden wird.

Wenn dem Rückgabewert ein const_iteratorWert zugewiesen ist, kann das Kartenobjekt nicht geändert werden. Wenn dem Rückgabewert ein iteratorWert zugewiesen ist, kann das Kartenobjekt geändert werden.

Beispiel

// map_upper_bound.cpp
// compile with: /EHsc
#include <map>
#include <iostream>

int main( )
{
   using namespace std;
   map <int, int> m1;
   map <int, int> :: const_iterator m1_AcIter, m1_RcIter;
   typedef pair <int, int> Int_Pair;

   m1.insert ( Int_Pair ( 1, 10 ) );
   m1.insert ( Int_Pair ( 2, 20 ) );
   m1.insert ( Int_Pair ( 3, 30 ) );

   m1_RcIter = m1.upper_bound( 2 );
   cout << "The first element of map m1 with a key "
        << "greater than 2 is: "
        << m1_RcIter -> second << "." << endl;

   // If no match is found for the key, end is returned
   m1_RcIter = m1. upper_bound ( 4 );

   if ( m1_RcIter == m1.end( ) )
      cout << "The map m1 doesn't have an element "
           << "with a key greater than 4." << endl;
   else
      cout << "The element of map m1 with a key > 4 is: "
           << m1_RcIter -> second << "." << endl;

   // The element at a specific location in the map can be found
   // using a dereferenced iterator addressing the location
   m1_AcIter = m1.begin( );
   m1_RcIter = m1. upper_bound ( m1_AcIter -> first );
   cout << "The 1st element of m1 with a key greater than\n"
        << "that of the initial element of m1 is: "
        << m1_RcIter -> second << "." << endl;
}

The first element of map m1 with a key greater than 2 is: 30.
The map m1 doesn't have an element with a key greater than 4.
The 1st element of m1 with a key greater than
that of the initial element of m1 is: 20.

`value_comp`

Die Memberfunktion gibt ein Funktionsobjekt zurück, das die Reihenfolge der Elemente in einer Zuordnung bestimmt, indem ihre Schlüsselwerte verglichen werden.

value_compare value_comp() const;

Rückgabewert

Gibt das Vergleichsfunktionsobjekt zurück, das ein map-Element zum Sortieren seiner Elemente verwendet.

Hinweise

Wenn für eine Karte m zwei Elemente e1(k1, d1) und e2(k2, d2) Objekte vom Typ value_typesind, wobei k1 und k1 ihre Schlüssel des Typs key_type sind und d1 und d2 ihre Datentypen mapped_typesind, entspricht m.key_comp(k1, k2)es dann m.value_comp(e1, e2) . Ein gespeichertes Objekt definiert die Memberfunktion

bool operator( value_type& left, value_type& right);

gibt zurück true , wenn der Schlüsselwert vorangestellter left Wert ist und nicht dem Schlüsselwert right in der Sortierreihenfolge entspricht.

Beispiel

// map_value_comp.cpp
// compile with: /EHsc
#include <map>
#include <iostream>

int main( )
{
   using namespace std;

   map <int, int, less<int> > m1;
   map <int, int, less<int> >::value_compare vc1 = m1.value_comp( );
   pair< map<int,int>::iterator, bool > pr1, pr2;

   pr1= m1.insert ( map <int, int> :: value_type ( 1, 10 ) );
   pr2= m1.insert ( map <int, int> :: value_type ( 2, 5 ) );

   if( vc1( *pr1.first, *pr2.first ) == true )
   {
      cout << "The element ( 1,10 ) precedes the element ( 2,5 )."
           << endl;
   }
   else
   {
      cout << "The element ( 1,10 ) does not precede the element ( 2,5 )."
           << endl;
   }

   if(vc1( *pr2.first, *pr1.first ) == true )
   {
      cout << "The element ( 2,5 ) precedes the element ( 1,10 )."
           << endl;
   }
   else
   {
      cout << "The element ( 2,5 ) does not precede the element ( 1,10 )."
           << endl;
   }
}

The element ( 1,10 ) precedes the element ( 2,5 ).
The element ( 2,5 ) does not precede the element ( 1,10 ).

`value_type`

Der Typ des Objekts, der als Element in einer Zuordnung gespeichert wird.

typedef pair<const Key, Type> value_type;

Beispiel

// map_value_type.cpp
// compile with: /EHsc
#include <map>
#include <iostream>

int main( )
{
   using namespace std;
   typedef pair <const int, int> cInt2Int;
   map <int, int> m1;
   map <int, int> :: key_type key1;
   map <int, int> :: mapped_type mapped1;
   map <int, int> :: value_type value1;
   map <int, int> :: iterator pIter;

   // value_type can be used to pass the correct type
   // explicitly to avoid implicit type conversion
   m1.insert ( map <int, int> :: value_type ( 1, 10 ) );

   // Compare other ways to insert objects into a map
   m1.insert ( cInt2Int ( 2, 20 ) );
   m1[ 3 ] = 30;

   // Initializing key1 and mapped1
   key1 = ( m1.begin( ) -> first );
   mapped1 = ( m1.begin( ) -> second );

   cout << "The key of first element in the map is "
        << key1 << "." << endl;

   cout << "The data value of first element in the map is "
        << mapped1 << "." << endl;

   // The following line would cause an error because
   // the value_type isn't assignable
   // value1 = cInt2Int ( 4, 40 );

   cout  << "The keys of the mapped elements are:";
   for ( pIter = m1.begin( ) ; pIter != m1.end( ) ; pIter++ )
      cout << " " << pIter -> first;
   cout << "." << endl;

   cout  << "The values of the mapped elements are:";
   for ( pIter = m1.begin( ) ; pIter != m1.end( ) ; pIter++ )
      cout << " " << pIter -> second;
   cout << "." << endl;
}

Siehe auch

Container
Threadsicherheit in der C++-Standardbibliothek
C++-Standardbibliotheksreferenz