`multimap`-Klasse

Artikel
10/12/2023

Die Multimap-Klasse der C++-Standardbibliothek wird für das Speichern und Abrufen von Daten aus einer Auflistung verwendet, in der jedes Element ein Paar ist, das sowohl einen Datenwert als auch einen Sortierschlüssel aufweist. Der Wert des Schlüssels muss nicht eindeutig sein und wird verwendet, um die Daten automatisch zu ordnen. Der Wert eines Elements in einer Mehrfachzuordnung, aber nicht der zugehörige Schlüsselwert, wird möglicherweise direkt geändert. Stattdessen müssen die Schlüsselwerte, die alten Elementen zugeordnet sind, gelöscht, und stattdessen neuen Schlüsselwerten für neue Elemente zugeordnet werden.

Syntax

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

Parameter

Key
Der in der Mehrfachzuordnung zu speichernde Schlüsseldatentyp.

Type
Der in der Mehrfachzuordnung zu speichernde Elementdatentyp.

Traits
Der Typ, der ein Funktionsobjekt bereitstellt, das zwei Elementwerte als Sortierschlüssel vergleichen kann, um deren relative Reihenfolge in der Mehrfachzuordnung zu bestimmen. Das binäre Prädikat less<Key> ist der Standardwert.

In C ++ 14 können Sie heterogenes Nachschlagen durch Angabe des std::less<> oder std::greater<> Prädikats, das keine Typparameter aufweist, aktivieren. Weitere Informationen finden Sie unter Heterogenes Nachschlagen in assoziativen Containern.

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

Auf die Mehrfachzuordnungsklasse der C++-Standardbibliothek treffen die folgenden Punkte zu:

Ein assoziativer Container, der ein Container variabler Größe ist, der den effizienten Abruf von Elementwerten auf Grundlage eines zugeordneten Schlüsselwert unterstützt.
Umkehrbar, da bidirektionale Iteratoren für den Zugriff auf die Elemente bereitgestellt werden.
Sortiert, da die Elemente anhand von Schlüsselwerten innerhalb des Containers mit einer angegebenen Vergleichsfunktion sortiert werden.
Mehrfach, da seine Elemente keinen eindeutigen Schlüssel aufweisen müssen, sodass einem Schlüsselwert möglicherweise viele Elementdatenwerte zugeordnet sind.
Ein Paar assoziativer Container, da sich die Elementdatenwerte von den Schlüsselwerten unterscheiden.
Eine Klassenvorlage, da die bereitgestellte Funktionalität generisch und so unabhängig vom spezifischen Datentyp ist, der als Elemente oder Schlüssel enthalten ist. Die für Elemente und Schlüssel zu verwendenden Datentypen werden stattdessen 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 Klassenmemberfunktionen insert und multimap verfügen über Versionen, die als Vorlagenparameter einen schwächeren Eingabe-Iterator verwenden, dessen Funktionalitätsanforderungen durch die Klasse bidirektionaler Iteratoren minimaler sind als diejenigen, die durch die Klasse bidirektionaler Iteratoren garantiert werden. Die verschiedenen Iteratorkonzepte bilden eine Family, die durch Verfeinerungen in ihrer Funktionen verknüpft ist. Jedes Iteratorkonzept weist einen eigenen Satz von Anforderungen auf, und die damit funktionierenden Algorithmen müssen die Annahmen hinsichtlich der von diesem Iteratortyp bereitgestellten Anforderungen begrenzen. Es kann davon ausgegangen werden, dass ein Eingabeiterator möglicherweise so dereferenziert wird, dass er auf ein Objekt verweist und dieses möglicherweise zum folgenden Iterator in der Sequenz erhöht. Das ist ein minimaler Funktionssatz, allerdings genügt er, um sinnvoll über einen Bereich von [First, Last)-Iteratoren im Kontext der Klassenmemberfunktionen zu sprechen.

Die Auswahl des Containertyps sollte im Allgemeinen auf Grundlage des für die Anwendung erforderlichen Suchen und Einfügetyps erfolgen. Assoziative Container sind auf Such-, Einfüge- und Entfernvorgänge optimiert. Die Memberfunktionen, die diese Vorgänge explizit unterstützen, sind effizient und führen sie in einer Zeit aus, die zum Logarithmus der Elementanzahl im Container im Durchschnitt proportional ist. Durch das Einfügen von Elementen werden keine Iteratoren ungültig, und durch das Entfernen von Elementen werden nur die Iteratoren ungültig, die auf die entfernten Elemente verwiesen haben.

Dies multimap sollte der assoziative Container der Wahl sein, wenn die Bedingungen, die die Werte mit ihren Schlüsseln verknüpfen, von der Anwendung erfüllt werden. Ein Modell für diesen Strukturtyp ist eine sortierte Liste von Schlüsselwörtern mit zugeordneten Zeichenfolgenwerten, die beispielsweise Definitionen enthalten, bei denen die Wörter nicht immer eindeutig definiert wurden. Wenn die Schlüsselwörter stattdessen eindeutig definiert werden, damit die Schlüssel eindeutig sind, ist eine Zuordnung der gewählte Container. Wenn hingegen nur die Wortliste gespeichert wurde, ist ein Satz der richtige Container. Wenn mehrere Vorkommen der Wörter zulässig wären, wäre eine multiset die entsprechende Containerstruktur.

Die multimap Reihenfolge, die sie steuert, wird durch Aufrufen eines gespeicherten Funktionsobjekts vom Typ key_comparesortiert. Dieses gespeicherte Objekt ist eine Vergleichsfunktion, auf die durch Aufrufen der Memberfunktion key_compzugegriffen werden kann. Im Allgemeinen müssen die Elemente der Vorwärtsiteratoren etwas weniger als vergleichbar sein, um diese Sortierung zu erstellen, sodass beliebige zwei Elemente möglicherweise als gleichwertig bestimmt werden (in dem Sinne, dass keins geringer als das Andere ist), oder dass eins geringer als das Andere ist. Dies führt zu einer Sortierung zwischen den nicht gleichwertigen Elementen. Etwas technischer betrachtet ist die Vergleichsfunktion ein binäres Prädikat, das eine strenge schwache Sortierung im mathematischen Sinn verursacht. Ein binäres Prädikat f(x,y) ist ein Funktionsobjekt mit zwei Argumentobjekten x und y einem 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 Äquivalenz transitiv ist, wobei zwei Objekte x und y definiert sind, wenn beide f(x,y) und f(y,x) gleich 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 heterogenes Nachschlagen durch Angabe des std::less<> oder std::greater<> Prädikats, das keine Typparameter aufweist, aktivieren. Weitere Informationen finden Sie unter heterogenes Nachschlagen in Associative Containers .

Member

Konstruktoren

Konstruktor	Beschreibung
`multimap`	Erstellt ein `multimap`-Element, das leer oder die Kopie eines ganzen anderen `multimap`-Elements oder eines Teils davon ist.

TypeDefs

Typname	Beschreibung
`allocator_type`	Ein Typ, der die `allocator`-Klassentyp für das `multimap`-Objekt darstellt.
`const_iterator`	Ein Typ, der einen bidirektionalen Iterator bereitstellt, der im `const`-Element ein `multimap`-Element lesen kann.
`const_pointer`	Ein Typ, der einen Zeiger auf ein `const`-Element in einem `multimap`-Element bereitstellt.
`const_reference`	Ein Typ, der einen Verweis auf ein `const`-Element bereitstellt, das in einem `multimap`-Element 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 `multimap`-Element lesen kann.
`difference_type`	Ein Ganzzahltyp mit Vorzeichen, der dazu verwendet werden kann, die Anzahl von Elementen eines `multimap`-Elements in einen Bereich zwischen Elementen darzustellen, auf die von Iteratoren gezeigt wird.
`iterator`	Ein Typ, der den Unterschied zwischen zwei Iteratoren, die auf Elemente innerhalb derselben `multimap` verweisen, bereitstellt.
`key_compare`	Eine Typ, der ein Funktionsobjekt bereitstellt, das zwei Sortierschlüssel vergleichen kann, um die relative Position von zwei Elementen im `multimap`-Element zu bestimmen.
`key_type`	Ein Typ, der das Sortierschlüsselobjekt beschreibt, aus dem jedes Element des Objekts `multimap`besteht.
`mapped_type`	Ein Typ, der den in einer `multimap` gespeicherten Datentyp darstellt.
`pointer`	Ein Typ, der einen Zeiger auf ein `const`-Element in einem `multimap`-Element bereitstellt.
`reference`	Ein Typ, der einen Verweis auf ein in einer `multimap` gespeichertes Element bereitstellt.
`reverse_iterator`	Ein Typ, der einen bidirektionalen Iterator bereitstellt, mit dem ein Element in einem umgekehrten `multimap`-Element gelesen oder geändert werden kann.
`size_type`	Ein ganze Zahl ohne Vorzeichen, die einen Zeiger auf ein `const`-Element in einer `multimap` bereitstellt.
`value_type`	Eine Typ, der ein Funktionsobjekt bereitstellt, das zwei Elemente als Sortierschlüssel vergleichen kann, um die relative Position im `multimap`-Element zu bestimmen.

Memberfunktionen

Memberfunktion	Beschreibung
`begin`	Gibt ein Iterator zurück, der das erste Element im `multimap`-Element adressiert.
`cbegin`	Gibt einen `const` Iterator zurück, der das erste Element in der `multimap`.
`cend`	Gibt einen `const` Iterator zurück, der die Position adressiert, die das letzte Element in einem `multimap`.
`clear`	Löscht alle Elemente einer `multimap` auf.
`contains`^C++20	Überprüft, ob ein Element mit dem angegebenen Schlüssel in der `multimap`.
`count`	Gibt die Anzahl von Elementen in einem `multimap`-Element zurück, dessen Schlüssel dem von einem Parameter angegebenen Schlüssel entspricht.
`crbegin`	Gibt einen `const` Iterator zurück, der das erste Element in einem umgekehrten Element adressiert `multimap`.
`crend`	Gibt einen `const` Iterator zurück, der die Position adressiert, die das letzte Element in einem umgekehrten Element erfolgreich war `multimap`.
`emplace`	Fügt ein Element ein, das vor Ort in ein `multimap`-Element erstellt wird.
`emplace_hint`	Fügt ein Element ein, das vor Ort mit einem Platzierungshinweis in ein `multimap`-Element erstellt wird.
`empty`	Testet, ob ein `multimap`-Element leer ist.
`end`	Gibt einen Iterator zurück, der den Speicherort adressiert, der dem letzten Element einem `multimap`-Element nachfolgt.
`equal_range`	Sucht den Bereich von Elementen, in dem der Schlüssel des Elements einem angegebenen Wert entspricht.
`erase`	Es wird ein Element oder ein Bereich von Elementen in einem `multimap` von angegebenen Speicherorten entfernt, oder es werden die einem angegebenen Schlüssel entsprechenden Elemente entfernt.
`find`	Gibt einen Iterator zurück, der die erste Position eines Elements in einem `multimap`-Element adressiert, das einen Schlüssel aufweist, der einem angegebenen Schlüssel entspricht.
`get_allocator`	Gibt eine Kopie des zum Erstellen von `allocator` verwendeten `multimap`-Objekts zurück.
`insert`	Fügt ein Element oder einen Elementbereich in ein `multimap`-Element ein.
`key_comp`	Ruft eine Kopie des Vergleichsobjekts ab, das zum Sortieren der Schlüssel in `multimap` verwendet wird.
`lower_bound`	Gibt einen Iterator zum ersten Element in einem `multimap`-Element mit einem Schlüssel zurück, der gleich oder größer ist als ein angegebener Schlüssel.
`max_size`	Gibt die Maximallänge der `multimap` zurück.
`rbegin`	Gibt einen Iterator zurück, der das erste Element in einem umgekehrten `multimap`-Element adressiert.
`rend`	Gibt einen Iterator zurück, der den Speicherort adressiert, der dem letzten Element eines umgekehrten `multimap`-Elements nachfolgt.
`size`	Gibt die Anzahl von Elementen in der `multimap` zurück.
`swap`	Tauscht die Elemente zweier `multimap`n.
`upper_bound`	Gibt einen Iterator zum ersten Element in einem `multimap`-Element mit einem Schlüssel zurück, der größer ist als ein angegebener Schlüssel.
`value_comp`	Die Memberfunktion gibt ein Funktionsobjekt zurück, das die Reihenfolge der Elemente in einer `multimap` bestimmt, indem ihre Schlüsselwerte verglichen werden.

Operator	Beschreibung
`operator=`	Ersetzt die Elemente eines `multimap`-Elements durch eine Kopie eines anderen `multimap`-Elements.

Anforderungen

Header<map>:

Namespace:std

Die ( Schlüssel- und Wert-) Paare werden als multimap Objekte vom Typ pairgespeichert. Für die Paarklasse ist der Header <utility>erforderlich, der automatisch von <map>.

`multimap::allocator_type`

Ein Typ, der die Allocator-Klasse für das multimap Objekt darstellt.

typedef Allocator allocator_type;

Beispiel

Sehen Sie sich das Beispiel für get_allocator ein Beispiel für die Verwendung von allocator_type.

`multimap::begin`

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

const_iterator begin() const;

iterator begin();

Rückgabewert

Ein bidirektionaler Iterator, der das erste Element in der oder an der Position angibt, an der multimap ein leerer Text ausgeführt multimapwird.

Beispiel

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

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

   multimap <int, int> :: iterator m1_Iter;
   multimap <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 as the iterator is const
   // m1_cIter = m1.begin ( );
   // m1.erase ( m1_cIter );

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

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

`multimap::cbegin`

Gibt einen const-Iterator zurück, mit dem das erste Element im Bereich behandelt wird.

const_iterator cbegin() const;

Rückgabewert

Ein bidirektionaler const-Access-Iterator, der auf das erste Element des Bereichs zeigt oder auf die Position direkt hinter dem Ende eines leeren Bereichs (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

`multimap::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 zurückgegebene cend Wert sollte nicht abgeleitet werden.

`multimap::clear`

Löscht alle Elemente einer multimap auf.

void clear();

Beispiel

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

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

int main( )
{
   using namespace std;
   multimap<int, int> m1;
   multimap<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 multimap is initially "
        << i << "." << endl;

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

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

`multimap::const_iterator`

Ein Typ, der einen bidirektionalen Iterator bereitstellt, der im const-Element ein multimap-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 Punkte definierten multimap Objekte von value_type, die vom Typ pair<const Key, Type>sind . Der Wert des Schlüssels ist durch das erste Memberpaar verfügbar, und der Wert des zugeordneten Elements durch das zweite Memberpaar.

Verwenden Sie den -> Operator, um ein const_iteratorcIter Element in einem multimapElement abzuleiten.

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

Beispiel

Sehen Sie sich das Beispiel für begin ein Beispiel für die Verwendung von const_iterator.

`multimap::const_pointer`

Ein Typ, der einen Zeiger auf ein const-Element in einem multimap-Element 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 Objekt verwendet werden, um auf die Elemente in einem multimap Objekt zuzugreifen.

`multimap::const_reference`

Ein Typ, der einen Verweis auf ein const-Element bereitstellt, das in einem multimap-Element zum Lesen und Ausführen von const-Vorgängen gespeichert ist.

typedef typename allocator_type::const_reference const_reference;

Beispiel

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

int main( )
{
   using namespace std;
   multimap <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 the first element in the multimap 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 the first element in the multimap is "
        << Ref2 << "." << endl;
}

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

`multimap::const_reverse_iterator`

Ein Typ, der einen bidirektionalen Iterator bereitstellt, der im const-Element jedes multimap-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 zum Durchlaufen des multimap umgekehrten Elements verwendet.

Die const_reverse_iterator durch Punkte definierten multimap Objekte von value_type, die vom Typ pair<const Key, Type>sind . Der Wert des Schlüssels ist durch das erste Memberpaar verfügbar, und der Wert des zugeordneten Elements durch das zweite Memberpaar.

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

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

Beispiel

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

`multimap::contains`

Überprüfen Sie, ob ein Element mit dem angegebenen Schlüssel in der multimap.

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::multimap<int, bool> m = {{0, false}, {1, true}};

    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::multimap<std::string, int, std::less<>> m2 = {{"ten", 10}, {"twenty", 20}, {"thirty", 30}};
    std::cout << m2.contains("ten");

    return 0;
}

true
false
true

`multimap::count`

Gibt die Anzahl der Elemente in einem multimap Schlüssel zurück, deren Schlüssel einem parameterspezifischen Schlüssel entsprechen.

size_type count(const Key& key) const;

Parameter

key
Der Schlüssel der Elemente, die aus der Mehrfachzuordnung abgeglichen werden.

Rückgabewert

Die Anzahl der Elemente, deren Sortierschlüssel mit dem Parameterschlüssel übereinstimmen; 0, wenn keine Mehrfachzuordnung ein Element mit einem übereinstimmenden Schlüssel enthält.

Hinweise

Die Memberfunktion gibt die Anzahl der Elemente im Bereich zurück.

lower_bound(key), upper_bound(key)

mit einem Schlüsselwert key.

Beispiel

Im folgenden Beispiel wird die Verwendung der Memberfunktion „hash_multimap::count“ gezeigt.

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

int main( )
{
    using namespace std;
    multimap<int, int> m1;
    multimap<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));

    // Elements don't need to have unique keys in multimap,
    // so duplicates are allowed and counted
    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: 2.
The number of elements in m1 with a sort key of 2 is: 2.
The number of elements in m1 with a sort key of 3 is: 0.

`multimap::crbegin`

Gibt einen const Iterator zurück, der das erste Element in einem umgekehrten Element adressiert multimap.

const_reverse_iterator crbegin() const;

Rückgabewert

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

Hinweise

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

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

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

Beispiel

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

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

   multimap <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 multimap m1 is "
        << m1_crIter -> first << "." << endl;
}

The first element of the reversed multimap m1 is 3.

`multimap::crend`

Gibt einen const Iterator zurück, der die Position adressiert, die das letzte Element in einem umgekehrten Element erfolgreich war multimap.

const_reverse_iterator crend() const;

Rückgabewert

Ein const umgekehrter bidirektionaler Iterator, der die Position adressiert, die das letzte Element in einem umgekehrten multimap Element erfolgreich war (die Position, die dem ersten Element in der unreversierten multimapSeite vorausging).

Hinweise

crend wird mit einem umgekehrten multimap verwendet, genau wie multimap::end bei einem multimap.

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

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

Der zurückgegebene crend Wert sollte nicht abgeleitet werden.

Beispiel

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

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

   multimap <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 multimap m1 is "
        << m1_crIter -> first << "." << endl;
}

The last element of the reversed multimap m1 is 1.

`multimap::difference_type`

Ein Ganzzahltyp mit Vorzeichen, der dazu verwendet werden kann, die Anzahl von Elementen eines multimap-Elements in einen Bereich zwischen Elementen darzustellen, auf die von Iteratoren gezeigt wird.

typedef typename allocator_type::difference_type difference_type;

Hinweise

difference_type ist der Typ, der beim Subtrahieren oder Inkrementieren über Iteratoren des Containers zurückgegeben wird. Dies difference_type wird in der Regel verwendet, um die Anzahl der Elemente im Bereich [first, last) zwischen den Iteratoren first und last, enthält das Element, auf first das verwiesen wird, und den Bereich der Elemente bis zu, jedoch nicht einschließlich, das Element, auf das verwiesen wird.last

Obwohl difference_type für alle Iteratoren verfügbar ist, die die Anforderungen eines Eingabe-Iterators erfüllen, die die Klasse bidirektionaler Iteratoren enthält, die von umkehrbaren Containern wie Set unterstützt werden, wird die Subtraktion zwischen Iteratoren nur von Iteratoren mit wahlfreiem Zugriff unterstützt, die von einem Zufallszugriffscontainer wie Vektor bereitgestellt werden.

Beispiel

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

int main( )
{
   using namespace std;
   multimap <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 ) );

   // The following will insert as multimap keys are not unique
   m1.insert ( Int_Pair ( 2, 30 ) );

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

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

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

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

`multimap::emplace`

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

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

Parameter

args
Die Argumente, die weitergeleitet werden, um ein Element zu konstruieren, das in das multimapElement eingefügt werden soll.

Rückgabewert

Ein Iterator zum neu eingefügten Element.

Hinweise

Von dieser Funktion werden keine Verweise auf Containerelemente für ungültig erklärt, aber möglicherweise werden alle Iteratoren für den Containers für ungültig erklärt.

Wenn während des Einfügens eine Ausnahme ausgelöst wird, bleibt der Container unverändert, und die Ausnahme wird erneut ausgelöst.

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

// multimap_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()
{
    multimap<string, string> m1;

    m1.emplace("Anna", "Accounting");
    m1.emplace("Bob", "Accounting");
    m1.emplace("Carmine", "Engineering");

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

    m1.emplace("Bob", "Engineering");

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

`multimap::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 das multimapElement eingefügt werden soll.

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.)

Rückgabewert

Ein Iterator zum neu eingefügten Element.

Hinweise

Von dieser Funktion werden keine Verweise auf Containerelemente für ungültig erklärt, aber möglicherweise werden alle Iteratoren für den Containers für ungültig erklärt.

Wird während des Einbaus eine Ausnahme ausgelöst, wird der Zustand des Containers nicht geändert.

Ein Codebeispiel finden Sie unter map::emplace_hint.

`multimap::empty`

Testet, ob ein multimap-Element leer ist.

bool empty() const;

Rückgabewert

true wenn die multimap leer ist; false wenn dies multimap nicht zu ernennen ist.

Beispiel

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

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

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

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

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

The multimap m1 is not empty.
The multimap m2 is empty.

`multimap::end`

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

const_iterator end() const;

iterator end();

Rückgabewert

Der "past-the-end"-Iterator. Wenn die multimap leer ist, gilt anschließend multimap::end() == multimap::begin().

Hinweise

end wird verwendet, um zu testen, ob ein Iterator das Ende seiner multimap.

Der zurückgegebene end Wert sollte nicht abgeleitet werden.

Ein Codebeispiel finden Sie unter multimap::find.

`multimap::equal_range`

Sucht den Bereich von Elementen, in dem der Schlüssel des Elements einem angegebenen Wert entspricht.

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

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

Parameter

key
Der Argumentschlüssel, der mit dem Sortierschlüssel eines Elements aus dem multimap durchsuchten Element verglichen werden soll.

Rückgabewert

Ein Paar Iteratoren, sodass der erste der lower_bound Schlüssel und der zweite der upper_bound Schlüssel ist.

Um auf den ersten Iterator eines von der Memberfunktion zurückgegebenen Paares pr zuzugreifen, verwenden pr.first Sie die Untergrenze *(pr.first)des Iterators, und leiten Sie es ab. Um auf den zweiten Iterator eines von der Memberfunktion zurückgegebenen Paares pr zuzugreifen, verwenden Sie den oberen begrenzungsfähigen Iterator, und pr.second leiten Sie es ab *(pr.second).

Beispiel

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

int main( )
{
   using namespace std;
   typedef multimap <int, int, less<int> > IntMMap;
   IntMMap m1;
   multimap <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 <IntMMap::const_iterator, IntMMap::const_iterator> p1, p2;
   p1 = m1.equal_range( 2 );

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

   cout << "The upper bound of the element with "
        << "a key of 2 in the multimap 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 multimap m1 doesn't have an element "
           << "with a key less than 4." << endl;
   else
      cout << "The element of multimap m1 with a key >= 40 is: "
           << p1.first -> first << "." << endl;
}

The lower bound of the element with a key of 2 in the multimap m1 is: 20.
The upper bound of the element with a key of 2 in the multimap 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 multimap m1 doesn't have an element with a key less than 4.

`multimap::erase`

Es wird ein Element oder ein Bereich von Elementen in einem multimap 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üssel 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.

Gibt für die dritte Memberfunktion die Anzahl der Elemente zurück, die aus dem multimapElement entfernt wurden.

Hinweise

Ein Codebeispiel finden Sie unter map::erase.

`multimap::find`

Gibt einen Iterator zurück, der auf die erste Position eines Elements in einem multimap Element verweist, das einen Schlüssel hat, der einem angegebenen Schlüssel entspricht.

iterator find(const Key& key);

const_iterator find(const Key& key) const;

Parameter

key
Der Schlüsselwert, der durch den Sortierschlüssel eines Elements abgeglichen werden soll, aus dem multimap durchsucht wird.

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 multimap (multimap::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 multimap 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 multimap Objekt nicht geändert werden. Wenn der Rückgabewert find eines iteratorObjekts zugewiesen ist, kann das multimap Objekt 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()
{
    multimap<int, string> m1({ { 40, "Zr" }, { 45, "Rh" } });
    cout << "The starting multimap 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 multimap m1 is (key, value):" << endl;
    print_collection(m1);
    cout << endl;
    findit(m1, 45);
    findit(m1, 6);
}

`multimap::get_allocator`

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

allocator_type get_allocator() const;

Rückgabewert

Der von der multimapZuweisung verwendete Allokator .

Hinweise

Allocators für die multimap Klasse geben an, wie die Klasse 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

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

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

   // The following lines declare objects
   // that use the default allocator.
   multimap <int, int> m1;
   multimap <int, int, allocator<int> > m2;
   multimap <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"
        << endl << "before free memory is exhausted: "
        << m2.max_size( ) << ".\n" << endl;

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

   // The following line creates a multimap m4
   // with the allocator of multimap 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 via the other
   if( m1_Alloc == m4_Alloc )
   {
      cout << "The allocators are interchangeable."
           << endl;
   }
   else
   {
      cout << "The allocators are not interchangeable."
           << endl;
   }
}

`multimap::insert`

Fügt ein Element oder einen Elementbereich in ein multimap-Element 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 das multimapElement eingefügt werden soll.

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 die Anforderungen eines input Iterators erfüllt, 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 Memberfunktionen für ein einzelnes Element einfügen (1) und (2) geben einen Iterator an die Position zurück, an der das neue Element eingefügt multimapwurde.

Die Elementfunktionen mit einem Element mit Hinweis, (3) und (4) geben einen Iterator zurück, der auf die Position zeigt, an der das neue Element in das multimapelement eingefügt wurde.

Hinweise

Von dieser Funktion werden keine Zeiger oder Verweise für ungültig erklärt, aber möglicherweise werden alle Iteratoren für den Containers für ungültig erklärt.

Wird beim Einfügen von nur einem Element eine Ausnahme ausgelöst, wird der Zustand des Containers 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.

Der value_type Container ist ein Typedef, der zum Container gehört, und für die Zuordnung multimap<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 Bereichselementfunktion (5) fügt die Abfolge von Elementwerten in ein multimap Element ein, das jedem Element entspricht, das von einem Iterator im Bereich [First, Last)adressiert wird; daher Last wird nicht eingefügt. Die Containermemberfunktion end() bezieht sich auf die Position direkt hinter dem letzten Element im Container. Z. B fügt die Anweisung m.insert(v.begin(), v.end()); alle Elemente von v in m ein.

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 multimap::emplace und multimap::emplace_hint.

Beispiel

// multimap_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
    multimap<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
    m1.insert(make_pair(1, 111));

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

    // 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
    multimap<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
    multimap<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;

    multimap<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;
}

`multimap::iterator`

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

typedef implementation-defined iterator;

Hinweise

Die iterator durch Punkte definierten multimap Objekte von value_type, die vom Typ pair<const Key, Type>sind . Der Wert des Schlüssels ist durch das erste Memberpaar verfügbar, und der Wert des zugeordneten Elements durch das zweite Memberpaar.

Verwenden Sie den -> Operator, um ein iteratorIter Element in einem multimapElement abzuleiten.

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.

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

Beispiel

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

`multimap::key_comp`

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

key_compare key_comp() const;

Rückgabewert

Gibt das Funktionsobjekt zurück, das zum multimap Sortieren seiner Elemente verwendet wird.

Hinweise

Das gespeicherte Objekt definiert die Memberfunktion

bool operator( const Key& x, const Key& y);

gibt "true" zurück, wenn x die Sortierreihenfolge streng vorausgeht y .

Beispiel

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

int main( )
{
   using namespace std;

   multimap <int, int, less<int> > m1;
   multimap <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;
   }

   multimap <int, int, greater<int> > m2;
   multimap <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.

`multimap::key_compare`

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

typedef Traits key_compare;

Hinweise

key_compare ist ein Synonym für den Vorlagenparameter Traits.

Weitere Informationen Traitsfinden Sie im multimap Thema "Klasse ".

Beispiel

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

`multimap::key_type`

Ein Typ, mit dem das Sortierschlüsselobjekt beschrieben wird, das jedes Element von multimap bildet.

typedef Key key_type;

Hinweise

key_type ist ein Synonym für den Vorlagenparameter Key.

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

Beispiel

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

`multimap::lower_bound`

Gibt einen Iterator zum ersten Element in einem multimap-Element mit einem Schlüssel 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üssel, der mit dem Sortierschlüssel eines Elements aus dem multimap durchsuchten Element verglichen werden soll.

Rückgabewert

Ein Iterator oder const_iterator die die Position eines Elements in einem multimap Element mit einem Schlüssel adressiert, der dem Argumentschlüssel entspricht oder größer als der Argumentschlüssel ist, oder die die Position adressiert, an der das letzte Element im letzten Element gefunden multimap wird, wenn keine Übereinstimmung für den Schlüssel gefunden wird.

Wenn der Rückgabewert lower_bound eines const_iteratorObjekts zugewiesen ist, kann das multimap Objekt nicht geändert werden. Wenn der Rückgabewert lower_bound einem Iterator zugewiesen ist, kann das multimap Objekt geändert werden.

Beispiel

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

int main( )
{
   using namespace std;
   multimap <int, int> m1;
   multimap <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, 20 ) );
   m1.insert ( Int_Pair ( 3, 30 ) );

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

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

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

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

   // The element at a specific location in the multimap 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 first element of m1 with a key matching\n"
        << "that of the last element is: "
        << m1_RcIter -> second << "." << endl;

   // Note that the first element with a key equal to
   // the key of the last element is not the last element
   if ( m1_RcIter == --m1.end( ) )
      cout << "This is the last element of multimap m1."
           << endl;
   else
      cout << "This is not the last element of multimap m1."
           << endl;
}

The element of multimap m1 with a key of 2 is: 20.
The first element of multimap m1 with a key of 3 is: 20.
The multimap m1 doesn't have an element with a key of 4.
The first element of m1 with a key matching
that of the last element is: 20.
This is not the last element of multimap m1.

`multimap::mapped_type`

Ein Typ, der den in einer multimap gespeicherten Datentyp darstellt.

typedef Type mapped_type;

Hinweise

mapped_type ist ein Synonym für den Vorlagenparameter Type.

Weitere Informationen Typefinden Sie im multimap Thema "Klasse ".

Beispiel

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

`multimap::max_size`

Gibt die Maximallänge der multimap zurück.

size_type max_size() const;

Rückgabewert

Die maximal mögliche Länge der multimap.

Beispiel

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

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

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

`multimap::multimap`

Erstellt ein multimap-Element, das leer oder die Kopie eines ganzen anderen multimap-Elements oder eines Teils davon ist.

multimap();

explicit multimap(
    const Traits& Comp);

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

map(
    const multimap& Right);

multimap(
    multimap&& Right);

multimap(
    initializer_list<value_type> IList);

multimap(
    initializer_list<value_type> IList,
    const Compare& Comp);

multimap(
    initializer_list<value_type> IList,
    const Compare& Comp,
    const Allocator& Al);

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

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

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

Parameter

Al
Die für dieses multimap-Objekt zu verwendende Speicherreservierungsklasse, dessen Standard "Allocator" ist.

Comp
Die Vergleichsfunktion vom Typ constTraits, die verwendet wird, um die Elemente in der Zuordnung zu sortieren, deren Standard Traits ist.

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, aus dem die Elemente kopiert werden sollen.

Hinweise

Alle Konstruktoren speichern einen Typ von Allocator-Objekt, der speicherverwaltung für die multimap 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 ihre multimap.

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

Die ersten drei Konstruktoren geben eine leere Initiale multimapan, 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 multimapRight.

Der fünfte Konstruktor gibt eine Kopie der multimap durch Verschieben nach rechts an.

Die Konstruktoren 6., 7. und 8. kopieren die Member einer .initializer_list

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

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

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

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

    // Create an empty multimap m1 with the key comparison
    // function of less than, then insert 4 elements
    multimap <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 multimap m2 with the key comparison
    // function of greater than, then insert 2 elements
    multimap <int, int, less<int> > m2;
    m2.insert(Int_Pair(1, 10));
    m2.insert(Int_Pair(2, 20));

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

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

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

    // Create a multimap m6 by copying the range m4[ first,  last)
    // and with the allocator of multimap m2
    multimap <int, int>::allocator_type m2_Alloc;
    m2_Alloc = m2.get_allocator();
    multimap <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 multimap m8 by copying in an initializer_list
    multimap<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 multimap m9 with an initializer_list and a comparator
    multimap<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 multimap m10 with an initializer_list, a comparator, and an allocator
    multimap<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;

}

`multimap::operator=`

Ersetzt die Elemente eines multimap-Elements durch eine Kopie eines anderen multimap-Elements.

multimap& operator=(const multimap& right);

multimap& operator=(multimap&& right);

Parameter

right
Das multimap kopierte In das multimap.

Hinweise

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

Beispiel

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

int main( )
   {
   using namespace std;
   multimap<int, int> v1, v2, v3;
   multimap<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;
   }

`multimap::pointer`

Ein Typ, der einen Zeiger auf ein Element in einer multimap 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 Objekt verwendet werden, um auf die Elemente in einem multimap Objekt zuzugreifen.

`multimap::rbegin`

Gibt einen Iterator zurück, der das erste Element in einem umgekehrten multimap-Element adressiert.

const_reverse_iterator rbegin() const;

reverse_iterator rbegin();

Rückgabewert

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

Hinweise

rbegin wird mit einem umgekehrten multimap verwendet, genau wie begin bei einem multimap.

Wenn der Rückgabewert rbegin eines const_reverse_iteratorObjekts zugewiesen ist, kann das multimap Objekt nicht geändert werden. Wenn der Rückgabewert rbegin eines reverse_iteratorObjekts zugewiesen ist, kann das multimap Objekt geändert werden.

Mit rbegin kann ein multimap rückwärts durchlaufen werden.

Beispiel

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

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

   multimap <int, int> :: iterator m1_Iter;
   multimap <int, int> :: reverse_iterator m1_rIter;
   multimap <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 multimap m1 is "
        << m1_rIter -> first << "." << endl;

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

   // A multimap element can be erased by dereferencing 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 multimap is "
        << m1_rIter -> first << "." << endl;
}

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

`multimap::reference`

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

typedef typename allocator_type::reference reference;

Beispiel

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

int main( )
{
   using namespace std;
   multimap <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 multimap 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 multimap 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 multimap is 1.
The data value of first element in the multimap is 10.
The modified data value of first element is 15.

`multimap::rend`

Gibt einen Iterator zurück, der den Speicherort adressiert, der dem letzten Element eines umgekehrten multimap-Elements nachfolgt.

const_reverse_iterator rend() const;

reverse_iterator rend();

Rückgabewert

Ein umgekehrter bidirektionaler Iterator, der die Position adressiert, die das letzte Element in einem umgekehrten multimap Element erfolgreich war (die Position, die dem ersten Element in der unreversierten multimapSeite vorausging).

Hinweise

rend wird mit einem umgekehrten multimap verwendet, genau wie end bei einem multimap.

Wenn der Rückgabewert rend eines const_reverse_iteratorObjekts zugewiesen ist, kann das multimap Objekt nicht geändert werden. Wenn der Rückgabewert rend eines reverse_iteratorObjekts zugewiesen ist, kann das multimap Objekt geändert werden.

rend kann verwendet werden, um zu testen, ob ein Umgekehrter Iterator das Ende des Iterators multimaperreicht hat.

Der zurückgegebene rend Wert sollte nicht abgeleitet werden.

Beispiel

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

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

   multimap <int, int> :: iterator m1_Iter;
   multimap <int, int> :: reverse_iterator m1_rIter;
   multimap <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 multimap m1 is "
        << m1_rIter -> first << "." << endl;

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

   // A multimap 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 multimap is "
        << m1_rIter -> first << "." << endl;
}

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

`multimap::reverse_iterator`

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

typedef std::reverse_iterator<iterator> reverse_iterator;

Hinweise

Ein Typ wird zum Durchlaufen des multimap umgekehrten Typs reverse_iterator verwendet.

Die reverse_iterator durch Punkte definierten multimap Objekte von value_type, die vom Typ pair<const Key, Type>sind . Der Wert des Schlüssels ist durch das erste Memberpaar verfügbar, und der Wert des zugeordneten Elements durch das zweite Memberpaar.

Verwenden Sie den -> Operator, um ein reverse_iteratorrIter Element in einem multimapElement abzuleiten.

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

Beispiel

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

`multimap::size`

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

size_type size() const;

Rückgabewert

Die aktuelle Länge des multimap.

Beispiel

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

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

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

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

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

The multimap length is 1.
The multimap length is now 2.

`multimap::size_type`

Ein ganzzahliger Typ ohne Vorzeichen, der die Anzahl der Elemente in einem multimap.

typedef typename allocator_type::size_type size_type;

Beispiel

Ein Beispiel für size das Deklarieren und Verwenden finden Sie im Beispiel size_type

`multimap::swap`

Tauscht die Elemente zweier multimapn.

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

Parameter

right
Die multimap Bereitstellung der zu tauschenden Elemente oder deren multimap Elemente sollen mit denen des multimapleftTauschs ausgetauscht werden.

Hinweise

Die Memberfunktion weist keine Verweise, Zeiger oder Iteratoren auf, die Elemente in den beiden multimapElementen kennzeichnen, deren Elemente ausgetauscht werden.

Beispiel

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

int main( )
{
   using namespace std;
   multimap <int, int> m1, m2, m3;
   multimap <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 multimap 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
   m1.swap( m2 );

   cout << "After swapping with m2, multimap 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, multimap m1 is:";
   for ( m1_Iter = m1.begin( ); m1_Iter != m1.end( ); m1_Iter++ )
      cout << " " << m1_Iter -> second;
   cout   << "." << endl;
}

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

`multimap::upper_bound`

Gibt eins iterator an das erste Element in einem multimap Element mit einem Schlüssel zurück, der größer als ein angegebener Schlüssel ist.

iterator upper_bound(const Key& key);

const_iterator upper_bound(const Key& key) const;

Parameter

key
Der Argumentschlüssel, der mit dem Sortierschlüssel eines Elements aus dem multimap durchsuchten Element verglichen werden soll.

Rückgabewert

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

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

Beispiel

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

int main( )
{
   using namespace std;
   multimap <int, int> m1;
   multimap <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.insert ( Int_Pair ( 3, 40 ) );

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

   m1_RcIter = m1.upper_bound( 2 );
   cout << "The first element of multimap 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.lower_bound( 4 );

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

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

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

`multimap::value_comp`

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

value_compare value_comp() const;

Rückgabewert

Gibt das Vergleichsfunktionsobjekt zurück, das zum multimap Sortieren seiner Elemente verwendet wird.

Hinweise

Bei einem multimapm, wenn zwei Elemente e1(k1, d1) und e2(k2, d2) Objekte vom Typ value_typesind , wobei k1 und k2 deren Schlüssel vom Typ key_type sind und d1 deren d2 Daten vom Typ mapped_typesind , dann entspricht m.key_comp(k1, k2)es m.value_comp(e1, e2) .

Beispiel

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

int main( )
{
   using namespace std;

   multimap <int, int, less<int> > m1;
   multimap <int, int, less<int> >::value_compare vc1 = m1.value_comp( );
   multimap<int,int>::iterator Iter1, Iter2;

   Iter1= m1.insert ( multimap <int, int> :: value_type ( 1, 10 ) );
   Iter2= m1.insert ( multimap <int, int> :: value_type ( 2, 5 ) );

   if( vc1( *Iter1, *Iter2 ) == 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( *Iter2, *Iter1 ) == 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 ).

`multimap::value_type`

Ein Typ, der dem als Element in einer Zuordnung gespeicherten Objekttyp entspricht.

typedef pair<const Key, Type> value_type;

Beispiel

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

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

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

   // Compare another way to insert objects into a hash_multimap
   m1.insert ( cInt2Int ( 2, 20 ) );

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

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

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

   // The following line would cause an error because
   // the value_type is not 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;
}

The key of first element in the multimap is 1.
The data value of first element in the multimap is 10.
The keys of the mapped elements are: 1 2.
The values of the mapped elements are: 10 20.

Siehe auch

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

multimap-Klasse

Syntax

Parameter

Hinweise

Member

Konstruktoren

TypeDefs

Memberfunktionen

Anforderungen

multimap::allocator_type

Beispiel

multimap::begin

Rückgabewert

Beispiel

multimap::cbegin

Rückgabewert

Hinweise

multimap::cend

Rückgabewert

Hinweise

multimap::clear

Beispiel

multimap::const_iterator

Hinweise

Beispiel

multimap::const_pointer

Hinweise

multimap::const_reference

Beispiel

multimap::const_reverse_iterator

Hinweise

Beispiel

multimap::contains

Parameter

Rückgabewert

Hinweise

Beispiel

multimap::count

Parameter

Rückgabewert

Hinweise

Beispiel

multimap::crbegin

Rückgabewert

Hinweise

Beispiel

multimap::crend

Rückgabewert

Hinweise

Beispiel

multimap::difference_type

Hinweise

Beispiel

multimap::emplace

Parameter

Rückgabewert

Hinweise

Beispiel

multimap::emplace_hint

Parameter

Rückgabewert

Hinweise

multimap::empty

Rückgabewert

Beispiel

multimap::end

Rückgabewert

Hinweise

multimap::equal_range

Parameter

Rückgabewert

Beispiel

multimap::erase

Parameter

Rückgabewert

Hinweise

multimap::find

Parameter

Rückgabewert

Hinweise

`multimap`-Klasse

`multimap::allocator_type`

`multimap::begin`

`multimap::cbegin`

`multimap::cend`

`multimap::clear`

`multimap::const_iterator`

`multimap::const_pointer`

`multimap::const_reference`

`multimap::const_reverse_iterator`

`multimap::contains`

`multimap::count`

`multimap::crbegin`

`multimap::crend`

`multimap::difference_type`

`multimap::emplace`

`multimap::emplace_hint`

`multimap::empty`

`multimap::end`

`multimap::equal_range`

`multimap::erase`

`multimap::find`

`multimap::get_allocator`

`multimap::insert`

`multimap::iterator`

`multimap::key_comp`

`multimap::key_compare`

`multimap::key_type`

`multimap::lower_bound`

`multimap::mapped_type`

`multimap::max_size`

`multimap::multimap`

`multimap::operator=`

`multimap::pointer`

`multimap::rbegin`

`multimap::reference`

`multimap::rend`

`multimap::reverse_iterator`

`multimap::size`

`multimap::size_type`

`multimap::swap`

`multimap::upper_bound`