map (STL/CLR)

Die Vorlagenklasse beschreibt ein Objekt, das eine unterschiedliche Sequenz von Elementen mit bidirektionalem Zugriff steuert. Sie verwenden den Container map , um eine Abfolge von Elementen als (fast) ausgeglichene Struktur von Knoten zu verwalten, wobei jedes Element gespeichert wird. Ein Element besteht aus einem Schlüssel, zum Sortieren der Sequenz und einem zugeordneten Wert, der für die Fahrt entlanggeht.

In der nachstehenden GValue Beschreibung ist die gleiche wie:

Microsoft::VisualC::StlClr::GenericPair<GKey, GMapped>

Dabei gilt Folgendes:

GKey ist identisch mit Key dem, es sei denn, dies ist ein Bezugstyp, in diesem Fall ist es Key^

GMapped ist identisch mit Mapped dem, es sei denn, dies ist ein Bezugstyp, in diesem Fall ist es Mapped^

Syntax

template<typename Key,
    typename Mapped>
    ref class map
        :   public
        System::ICloneable,
        System::Collections::IEnumerable,
        System::Collections::ICollection,
        System::Collections::Generic::IEnumerable<GValue>,
        System::Collections::Generic::ICollection<GValue>,
        System::Collections::Generic::IList<GValue>,
        System::Collections::Generic::IDictionary<Gkey, GMapped>,
        Microsoft::VisualC::StlClr::ITree<Gkey, GValue>
    { ..... };

Parameter

Key
Der Typ der Schlüsselkomponente eines Elements in der gesteuerten Sequenz.

Mapped
Der Typ der anderen Komponente eines Elements in der gesteuerten Sequenz.

Anforderungen

Header:<cliext/map>

Namespace:cliext

Deklarationen

Typdefinition	Beschreibung
map::const_iterator	Der Typ eines konstanten Iterators für die gesteuerte Sequenz.
map::const_reference	Der Typ eines konstanten Verweises auf ein Element.
map::const_reverse_iterator	Der Typ eines konstanten umgekehrten Iterators für die gesteuerte Sequenz.
map::difference_type	Der Typ eines (möglicherweise signierten) Abstands zwischen zwei Elementen.
map::generic_container	Der Typ der generischen Schnittstelle für den Container.
map::generic_iterator	Der Typ eines Iterators für die generische Schnittstelle für den Container.
map::generic_reverse_iterator	Der Typ eines Reverse iterators für die generische Schnittstelle für den Container.
map::generic_value	Der Typ eines Elements für die generische Schnittstelle für den Container.
map::iterator	Der Typ eines Iterators für die gesteuerte Sequenz.
map::key_compare	Der Sortierdelegat für zwei Schlüssel.
map::key_type	Der Typ eines Sortierschlüssels.
map::mapped_type	Der Typ des zugeordneten Werts, der den einzelnen Schlüsseln zugeordnet ist.
map::reference	Der Typ eines Verweises auf ein Element.
map::reverse_iterator	Der Typ eines umgekehrten Iterators für die gesteuerte Sequenz.
map::size_type	Der Typ eines (nicht negativen) Abstands zwischen zwei Elementen.
map::value_compare	Der Sortierdelegat für zwei Elementwerte.
map::value_type	Der Typ eines Elements.

Memberfunktion	Beschreibung
map::begin	Legt den Anfang der kontrollierten Sequenz fest.
map::clear	Entfernt alle Elemente.
map::count	Zählt Elemente, die einem angegebenen Schlüssel entsprechen.
map::empty	Testet, ob keine Elemente vorhanden sind.
map::end	Legt das Ende der kontrollierten Sequenz fest.
map::equal_range	Sucht den Bereich, der einem angegebenen Schlüssel entspricht.
map::erase	Entfernt Elemente an den angegebenen Positionen.
map::find	Sucht ein Element, das einem angegebenen Schlüssel entspricht.
map::insert	Fügt Elemente hinzu.
map::key_comp	Kopiert den Sortierdelegat für zwei Schlüssel.
map::lower_bound	Sucht den Anfang des Bereichs, der einem angegebenen Schlüssel entspricht.
map::make_value	Erstellt ein Wertobjekt.
map::map	Erstellt ein container-Objekt.
map::rbegin	Legt den Anfang der umgekehrten kontrollierten Sequenz fest.
map::rend	Legt das Ende der umgekehrten kontrollierten Sequenz fest.
map::size	Ermittelt die Anzahl von Elementen.
map::swap	Vertauscht den Inhalt von zwei Containern.
map::to_array	Kopiert die kontrollierte Sequenz in ein neues Array.
map::upper_bound	Sucht das Ende des Bereichs, der einem angegebenen Schlüssel entspricht.
map::value_comp	Kopiert den Sortierdelegat für zwei Elementwerte.

Operator	Beschreibung
map::operator=	Ersetzt die kontrollierte Sequenz.
map::operator[]	Ordnet einen Schlüssel dem zugeordneten zugeordneten Wert zu.
operator!= (Karte)	Bestimmt, ob ein Objekt nicht mit einem map anderen map Objekt identisch ist.
operator< (Karte)	Bestimmt, ob ein Objekt kleiner als ein map anderes map Objekt ist.
operator<= (Karte)	Bestimmt, ob ein Objekt kleiner oder gleich einem map anderen map Objekt ist.
operator== (Karte)	Bestimmt, ob ein Objekt mit einem map anderen map Objekt identisch ist.
operator> (Karte)	Bestimmt, ob ein Objekt größer als ein map anderes map Objekt ist.
operator>= (Karte)	Bestimmt, ob ein Objekt größer oder gleich einem map anderen map Objekt ist.

Schnittstellen

Schnittstelle	Beschreibung
ICloneable	Duplizieren Eines Objekts.
IEnumerable	Sequenzieren durch Elemente.
ICollection	Verwalten sie eine Gruppe von Elementen.
IEnumerable<T>	Sequenz durch eingegebene Elemente.
ICollection<T>	Verwalten der Gruppe von typierten Elementen.
IDictionary<TKey,TValue>	Verwalten der Gruppe von {key,value}-Paaren.
ITree<Key, Value>	Verwalten Sie generischen Container.

Hinweise

Das Objekt reserviert und gibt Speicherplatz für die Sequenz frei, die es als einzelne Knoten steuert. Es fügt Elemente in eine (fast) ausgewogene Struktur ein, die sie beibehalten, indem sie die Verknüpfungen zwischen Knoten ändert, niemals durch Kopieren des Inhalts eines Knotens in einen anderen. Das bedeutet, dass Sie Elemente frei einfügen und entfernen können, ohne die verbleibenden Elemente zu stören.

Das Objekt sortiert die Reihenfolge, die es steuert, indem ein gespeichertes Delegatobjekt vom Typ map::key_compareaufgerufen wird. Sie können das gespeicherte Delegatobjekt angeben, wenn Sie die Zuordnung erstellen. wenn Sie kein Delegatobjekt angeben, ist der Standardwert der Vergleich operator<(key_type, key_type). Sie greifen auf dieses gespeicherte Objekt zu, indem Sie die Memberfunktion map::key_compaufrufen.

Ein solches Delegatobjekt muss eine strenge schwache Reihenfolge für Schlüssel vom Typ map::key_typeauferlegen. Dies bedeutet, dass für alle zwei Schlüssel X und Y:

key_comp()(X, Y) gibt dasselbe boolesche Ergebnis für jeden Anruf zurück.

Ist key_comp()(X, Y) "true", muss " key_comp()(Y, X) false" angegeben werden.

Wenn key_comp()(X, Y) dies der Fall ist, wird gesagt, X dass sie vorher Ybestellt werden.

Wenn !key_comp()(X, Y) && !key_comp()(Y, X) dies der Fall ist, dann und Y wird davon gesprochen, X dass sie eine gleichwertige Sortierung haben.

Für jedes Element X , das in der kontrollierten Sequenz vorausgeht Y , key_comp()(Y, X) ist "false". (Für das Standarddelegatobjekt verringern die Schlüssel niemals den Wert.) Im Gegensatz zur Vorlagenklassenzuordnung erfordert ein Objekt der Vorlagenklasse map nicht, dass Schlüssel für alle Elemente eindeutig sind. (Zwei oder mehr Schlüssel können eine gleichwertige Reihenfolge aufweisen.)

Jedes Element enthält einen separaten Schlüssel und einen zugeordneten Wert. Die Sequenz wird in einer Weise dargestellt, die das Nachschlagen, Einfügen und Entfernen eines beliebigen Elements in logarithmischer Zeit zulässt. Das heißt, die Anzahl der Vorgänge ist proportional zum Logarithmus der Anzahl der Elemente in der Sequenz. Darüber hinaus wird durch das Einfügen eines Elements keine Iteratoren ungültig, und durch das Entfernen eines Elements werden nur die Iteratoren ungültig, die auf das entfernte Element zeigen.

A map supports bidirectional iterators, which means you can step to adjacent elements given an iterator that designates an element in the controlled sequence. Ein spezieller Kopfknoten entspricht dem iterator, von end()dem zurückgegeben wird. Sie können diesen Iterator verringern, um das letzte Element in der gesteuerten Sequenz zu erreichen, falls vorhanden. Sie können einen map Iterator erhöhen, um den Kopfknoten zu erreichen, und es wird dann gleich end()verglichen. Sie können jedoch nicht ableiten, von dem der Iterator zurückgegeben wird end().

Sie können nicht direkt auf ein map Element verweisen, das seine numerische Position aufweist. Dies erfordert einen Iterator für zufälligen Zugriff.

Ein map Iterator speichert ein Handle für den zugeordneten map Knoten, der wiederum ein Handle für den zugeordneten Container speichert. Sie können Iteratoren nur mit den zugehörigen Containerobjekten verwenden. Ein map Iterator bleibt gültig, solange der zugehörige map Knoten einer Karte zugeordnet ist. Darüber hinaus ist ein gültiger Iterator ableitend. Sie können ihn verwenden, um auf den von ihr angegebenen Elementwert zuzugreifen oder ihn zu ändern, solange er nicht gleich end()ist.

Beim Löschen oder Entfernen eines Elements wird der Destruktor für den gespeicherten Wert aufgerufen. Durch das Zerstören des Containers werden alle Elemente gelöscht. Daher stellt ein Container, dessen Elementtyp eine Ref-Klasse ist, sicher, dass keine Elemente den Container überleben. Ein Container mit Ziehpunkten zerstört seine Elemente jedoch nicht.

Member

map::begin

Legt den Anfang der kontrollierten Sequenz fest.

Syntax

iterator begin();

Hinweise

Die Memberfunktion gibt einen bidirektionalen Iterator zurück, der das erste Element der gesteuerten Sequenz oder direkt über das Ende einer leeren Sequenz bestimmt. Sie verwenden es, um einen Iterator zu erhalten, der den current Anfang der kontrollierten Sequenz angibt, aber sein Status kann sich ändern, wenn sich die Länge der kontrollierten Sequenz ändert.

Beispiel

// cliext_map_begin.cpp
// compile with: /clr
#include <cliext/map>

typedef cliext::map<wchar_t, int> Mymap;
int main()
    {
    Mymap c1;
    c1.insert(Mymap::make_value(L'a', 1));
    c1.insert(Mymap::make_value(L'b', 2));
    c1.insert(Mymap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Mymap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // inspect first two items
    Mymap::iterator it = c1.begin();
    System::Console::WriteLine("*begin() = [{0} {1}]",
        it->first, it->second);
    ++it;
    System::Console::WriteLine("*++begin() = [{0} {1}]",
        it->first, it->second);
    return (0);
    }

[a 1] [b 2] [c 3]
*begin() = [a 1]
*++begin() = [b 2]

map::clear

Entfernt alle Elemente.

Syntax

void clear();

Hinweise

Die Memberfunktion ruft effektiv auf erase(begin(), end()). Sie verwenden es, um sicherzustellen, dass die kontrollierte Sequenz leer ist.

Beispiel

// cliext_map_clear.cpp
// compile with: /clr
#include <cliext/map>

typedef cliext::map<wchar_t, int> Mymap;
int main()
    {
    Mymap c1;
    c1.insert(Mymap::make_value(L'a', 1));
    c1.insert(Mymap::make_value(L'b', 2));
    c1.insert(Mymap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Mymap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // clear the container and reinspect
    c1.clear();
    System::Console::WriteLine("size() = {0}", c1.size());

    c1.insert(Mymap::make_value(L'a', 1));
    c1.insert(Mymap::make_value(L'b', 2));

    // display contents " [a 1] [b 2]"
    for each (Mymap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();
    c1.clear();
    System::Console::WriteLine("size() = {0}", c1.size());
    return (0);
    }

[a 1] [b 2] [c 3]
size() = 0
[a 1] [b 2]
size() = 0

map::const_iterator

Der Typ eines konstanten Iterators für die gesteuerte Sequenz.

Syntax

typedef T2 const_iterator;

Hinweise

Der Typ beschreibt ein Objekt nicht angegebener Typs T2 , das als konstanter bidirektionaler Iterator für die kontrollierte Sequenz dienen kann.

Beispiel

// cliext_map_const_iterator.cpp
// compile with: /clr
#include <cliext/map>

typedef cliext::map<wchar_t, int> Mymap;
int main()
    {
    Mymap c1;
    c1.insert(Mymap::make_value(L'a', 1));
    c1.insert(Mymap::make_value(L'b', 2));
    c1.insert(Mymap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    Mymap::const_iterator cit = c1.begin();
    for (; cit != c1.end(); ++cit)
        System::Console::Write("[{0} {1}] ", cit->first, cit->second);
    System::Console::WriteLine();
    return (0);
    }

[a 1] [b 2] [c 3]

map::const_reference

Der Typ eines konstanten Verweises auf ein Element.

Syntax

typedef value_type% const_reference;

Hinweise

Der Typ beschreibt einen Konstantenverweis auf ein Element.

Beispiel

// cliext_map_const_reference.cpp
// compile with: /clr
#include <cliext/map>

typedef cliext::map<wchar_t, int> Mymap;
int main()
    {
    Mymap c1;
    c1.insert(Mymap::make_value(L'a', 1));
    c1.insert(Mymap::make_value(L'b', 2));
    c1.insert(Mymap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    Mymap::const_iterator cit = c1.begin();
    for (; cit != c1.end(); ++cit)
        {   // get a const reference to an element
        Mymap::const_reference cref = *cit;
        System::Console::Write("[{0} {1}] ", cref->first, cref->second);
        }
    System::Console::WriteLine();
    return (0);
    }

[a 1] [b 2] [c 3]

map::const_reverse_iterator

Der Typ eines konstanten umgekehrten Iterators für die gesteuerte Sequenz.

Syntax

typedef T4 const_reverse_iterator;

Hinweise

Der Typ beschreibt ein Objekt nicht angegebener Typs T4 , das als konstanten Reverse iterator für die kontrollierte Sequenz dienen kann.

Beispiel

// cliext_map_const_reverse_iterator.cpp
// compile with: /clr
#include <cliext/map>

typedef cliext::map<wchar_t, int> Mymap;
int main()
    {
    Mymap c1;
    c1.insert(Mymap::make_value(L'a', 1));
    c1.insert(Mymap::make_value(L'b', 2));
    c1.insert(Mymap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]" reversed
    Mymap::const_reverse_iterator crit = c1.rbegin();
    for (; crit != c1.rend(); ++crit)
        System::Console::Write("[{0} {1}] ", crit->first, crit->second);
    System::Console::WriteLine();
    return (0);
    }

[c 3] [b 2] [a 1]

map::count

Sucht die Anzahl von Elementen, die einem angegebenen Schlüssel entsprechen.

Syntax

size_type count(key_type key);

Parameter

key
Der zu suchende Schlüsselwert.

Hinweise

Die Memberfunktion gibt die Anzahl der Elemente in der kontrollierten Sequenz zurück, die eine entsprechende Reihenfolge aufweisen.key Sie verwenden es, um die Anzahl der Elemente zu bestimmen, die sich derzeit in der kontrollierten Sequenz befindet, die einem angegebenen Schlüssel entsprechen.

Beispiel

// cliext_map_count.cpp
// compile with: /clr
#include <cliext/map>

typedef cliext::map<wchar_t, int> Mymap;
int main()
    {
    Mymap c1;
    c1.insert(Mymap::make_value(L'a', 1));
    c1.insert(Mymap::make_value(L'b', 2));
    c1.insert(Mymap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Mymap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    System::Console::WriteLine("count(L'A') = {0}", c1.count(L'A'));
    System::Console::WriteLine("count(L'b') = {0}", c1.count(L'b'));
    System::Console::WriteLine("count(L'C') = {0}", c1.count(L'C'));
    return (0);
    }

[a 1] [b 2] [c 3]
count(L'A') = 0
count(L'b') = 1
count(L'C') = 0

map::difference_type

Die Typen eines signierten Abstands zwischen zwei Elementen.

Syntax

typedef int difference_type;

Hinweise

Der Typ beschreibt eine möglicherweise negative Elementanzahl.

Beispiel

// cliext_map_difference_type.cpp
// compile with: /clr
#include <cliext/map>

typedef cliext::map<wchar_t, int> Mymap;
int main()
    {
    Mymap c1;
    c1.insert(Mymap::make_value(L'a', 1));
    c1.insert(Mymap::make_value(L'b', 2));
    c1.insert(Mymap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Mymap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // compute positive difference
    Mymap::difference_type diff = 0;
    for (Mymap::iterator it = c1.begin(); it != c1.end(); ++it)
        ++diff;
    System::Console::WriteLine("end()-begin() = {0}", diff);

    // compute negative difference
    diff = 0;
    for (Mymap::iterator it = c1.end(); it != c1.begin(); --it)
        --diff;
    System::Console::WriteLine("begin()-end() = {0}", diff);
    return (0);
    }

[a 1] [b 2] [c 3]
end()-begin() = 3
begin()-end() = -3

map::empty

Testet, ob keine Elemente vorhanden sind.

Syntax

bool empty();

Hinweise

Die Memberfunktion gibt „true“ für eine leere gesteuerte Sequenz zurück. Dies entspricht size() == 0. Sie verwenden es, um zu testen, ob die Datei map leer ist.

Beispiel

// cliext_map_empty.cpp
// compile with: /clr
#include <cliext/map>

typedef cliext::map<wchar_t, int> Mymap;
int main()
    {
    Mymap c1;
    c1.insert(Mymap::make_value(L'a', 1));
    c1.insert(Mymap::make_value(L'b', 2));
    c1.insert(Mymap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Mymap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();
    System::Console::WriteLine("size() = {0}", c1.size());
    System::Console::WriteLine("empty() = {0}", c1.empty());

    // clear the container and reinspect
    c1.clear();
    System::Console::WriteLine("size() = {0}", c1.size());
    System::Console::WriteLine("empty() = {0}", c1.empty());
    return (0);
    }

[a 1] [b 2] [c 3]
size() = 3
empty() = False
size() = 0
empty() = True

map::end

Legt das Ende der kontrollierten Sequenz fest.

Syntax

iterator end();

Hinweise

Die Memberfunktion gibt einen bidirektionalen Iterator zurück, der unmittelbar über das Ende der gesteuerten Sequenz verweist. Sie verwenden es, um einen Iterator zu erhalten, der das Ende der kontrollierten Sequenz angibt; der Status ändert sich nicht, wenn sich die Länge der kontrollierten Sequenz ändert.

Beispiel

// cliext_map_end.cpp
// compile with: /clr
#include <cliext/map>

typedef cliext::map<wchar_t, int> Mymap;
int main()
    {
    Mymap c1;
    c1.insert(Mymap::make_value(L'a', 1));
    c1.insert(Mymap::make_value(L'b', 2));
    c1.insert(Mymap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Mymap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // inspect last two items
    Mymap::iterator it = c1.end();
    --it;
    --it;
    System::Console::WriteLine("*-- --end() = [{0} {1}]",
        it->first, it->second);
    ++it;
    System::Console::WriteLine("*--end() = [{0} {1}]",
        it->first, it->second);
    return (0);
    }

map::equal_range

Sucht den Bereich, der einem angegebenen Schlüssel entspricht.

Syntax

cliext::pair<iterator, iterator> equal_range(key_type key);

Parameter

key
Der zu suchende Schlüsselwert.

Hinweise

Die Memberfunktion gibt ein Iteratorpaar cliext::pair<iterator, iterator>(lower_bound(key), upper_bound(key))zurück. Sie verwenden es, um den Bereich der Elemente zu bestimmen, die sich derzeit in der kontrollierten Sequenz befinden, die einem angegebenen Schlüssel entsprechen.

Beispiel

// cliext_map_equal_range.cpp
// compile with: /clr
#include <cliext/map>

typedef cliext::map<wchar_t, int> Mymap;
typedef Mymap::pair_iter_iter Pairii;
int main()
    {
    Mymap c1;
    c1.insert(Mymap::make_value(L'a', 1));
    c1.insert(Mymap::make_value(L'b', 2));
    c1.insert(Mymap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Mymap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // display results of failed search
    Pairii pair1 = c1.equal_range(L'x');
    System::Console::WriteLine("equal_range(L'x') empty = {0}",
        pair1.first == pair1.second);

    // display results of successful search
    pair1 = c1.equal_range(L'b');
    for (; pair1.first != pair1.second; ++pair1.first)
        System::Console::Write("[{0} {1}] ",
            pair1.first->first, pair1.first->second);
    System::Console::WriteLine();
    return (0);
    }

[a 1] [b 2] [c 3]
equal_range(L'x') empty = True
[b 2]

map::erase

Entfernt Elemente an den angegebenen Positionen.

Syntax

iterator erase(iterator where);
iterator erase(iterator first, iterator last);
bool erase(key_type key)

Parameter

first
Anfang des zu löschenden Bereichs.

key
Schlüsselwert, der gelöscht werden soll.

last
Ende des zu löschenden Bereichs.

where
Element, das gelöscht werden soll.

Hinweise

Die erste Memberfunktion entfernt das Element der kontrollierten Abfolge, auf die verwiesen wherewird, und gibt einen Iterator zurück, der das erste Element angibt, das über das entfernte Element hinaus verbleibt, oder end() wenn kein solches Element vorhanden ist. Sie verwenden es, um ein einzelnes Element zu entfernen.

Die zweite Memberfunktion entfernt die Elemente der kontrollierten Sequenz im Bereich [first, ), und gibt einen Iterator zurück, lastder das erste Element angibt, das über alle entfernten Elemente hinaus verbleibt, oder end() wenn kein solches Element vorhanden ist. Sie verwenden es, um null oder mehr zusammenhängende Elemente zu entfernen.

Die dritte Memberfunktion entfernt alle Elemente der gesteuerten Sequenz, deren Schlüssel die entsprechende Reihenfolge keyaufweist, und gibt eine Anzahl der entfernten Elemente zurück. Sie verwenden es, um alle Elemente zu entfernen und zu zählen, die einem angegebenen Schlüssel entsprechen.

Jedes Elementlöschung dauert Zeit proportional zum Logarithmus der Anzahl der Elemente in der kontrollierten Sequenz.

Beispiel

// cliext_map_erase.cpp
// compile with: /clr
#include <cliext/map>

typedef cliext::map<wchar_t, int> Mymap;
int main()
    {
    cliext::map<wchar_t, int> c1;
    c1.insert(cliext::map<wchar_t, int>::make_value(L'a', 1));
    c1.insert(cliext::map<wchar_t, int>::make_value(L'b', 2));
    c1.insert(cliext::map<wchar_t, int>::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (cliext::map<wchar_t, int>::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // erase an element and reinspect
    cliext::map<wchar_t, int>::iterator it =
        c1.erase(c1.begin());
    System::Console::WriteLine("erase(begin()) = [{0} {1}]",
        it->first, it->second);

    // add elements and display " b c d e"
    c1.insert(cliext::map<wchar_t, int>::make_value(L'd', 4));
    c1.insert(cliext::map<wchar_t, int>::make_value(L'e', 5));
    for each (cliext::map<wchar_t, int>::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // erase all but end
    it = c1.end();
    it = c1.erase(c1.begin(), --it);
    System::Console::WriteLine("erase(begin(), end()-1) = [{0} {1}]",
        it->first, it->second);
    System::Console::WriteLine("size() = {0}", c1.size());

    // erase end
    System::Console::WriteLine("erase(L'x') = {0}", c1.erase(L'x'));
    System::Console::WriteLine("erase(L'e') = {0}", c1.erase(L'e'));
    return (0);
    }

[a 1] [b 2] [c 3]
erase(begin()) = [b 2]
[b 2] [c 3] [d 4] [e 5]
erase(begin(), end()-1) = [e 5]
size() = 1
erase(L'x') = 0
erase(L'e') = 1

map::find

Sucht ein Element, das einem angegebenen Schlüssel entspricht.

Syntax

iterator find(key_type key);

Parameter

key
Der zu suchende Schlüsselwert.

Hinweise

Wenn mindestens ein Element in der kontrollierten Sequenz eine gleichwertige Reihenfolge aufweist key, gibt die Memberfunktion einen Iterator zurück, der eines dieser Elemente bestimmt; andernfalls wird es zurückgegeben end(). Sie verwenden es, um ein Element zu finden, das sich derzeit in der kontrollierten Sequenz befindet, die einem angegebenen Schlüssel entspricht.

Beispiel

// cliext_map_find.cpp
// compile with: /clr
#include <cliext/map>

typedef cliext::map<wchar_t, int> Mymap;
int main()
    {
    Mymap c1;
    c1.insert(Mymap::make_value(L'a', 1));
    c1.insert(Mymap::make_value(L'b', 2));
    c1.insert(Mymap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Mymap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    System::Console::WriteLine("find {0} = {1}",
        L'A', c1.find(L'A') != c1.end());

    Mymap::iterator it = c1.find(L'b');
    System::Console::WriteLine("find {0} = [{1} {2}]",
        L'b', it->first, it->second);

    System::Console::WriteLine("find {0} = {1}",
        L'C', c1.find(L'C') != c1.end());
    return (0);
    }

[a 1] [b 2] [c 3]
find A = False
find b = [b 2]
find C = False

map::generic_container

Der Typ der generischen Schnittstelle für den Container.

Syntax

typedef Microsoft::VisualC::StlClr::
    ITree<GKey, GValue>
    generic_container;

Hinweise

Der Typ beschreibt die generische Schnittstelle für diese Vorlagencontainerklasse.

Beispiel

// cliext_map_generic_container.cpp
// compile with: /clr
#include <cliext/map>

typedef cliext::map<wchar_t, int> Mymap;
int main()
    {
    Mymap c1;
    c1.insert(Mymap::make_value(L'a', 1));
    c1.insert(Mymap::make_value(L'b', 2));
    c1.insert(Mymap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Mymap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // construct a generic container
    Mymap::generic_container^ gc1 = %c1;
    for each (Mymap::value_type elem in gc1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // modify generic and display original
    gc1->insert(Mymap::make_value(L'd', 4));
    for each (Mymap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // modify original and display generic
    c1.insert(Mymap::make_value(L'e', 5));
    for each (Mymap::value_type elem in gc1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();
    return (0);
    }

[a 1] [b 2] [c 3]
[a 1] [b 2] [c 3]
[a 1] [b 2] [c 3] [d 4]
[a 1] [b 2] [c 3] [d 4] [e 5]

map::generic_iterator

Der Typ eines Iterators für die Verwendung mit der generischen Schnittstelle für den Container.

Syntax

typedef Microsoft::VisualC::StlClr::Generic::
    ContainerBidirectionalIterator<generic_value>
    generic_iterator;

Hinweise

Der Typ beschreibt einen generischen Iterator, der mit der generischen Schnittstelle für diese Vorlagencontainerklasse verwendet werden kann.

Beispiel

// cliext_map_generic_iterator.cpp
// compile with: /clr
#include <cliext/map>

typedef cliext::map<wchar_t, int> Mymap;
int main()
    {
    Mymap c1;
    c1.insert(Mymap::make_value(L'a', 1));
    c1.insert(Mymap::make_value(L'b', 2));
    c1.insert(Mymap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Mymap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // construct a generic container
    Mymap::generic_container^ gc1 = %c1;
    for each (Mymap::value_type elem in gc1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // get an element and display it
    Mymap::generic_iterator gcit = gc1->begin();
    Mymap::generic_value gcval = *gcit;
    System::Console::Write("[{0} {1}] ", gcval->first, gcval->second);
    System::Console::WriteLine();
    return (0);
    }

[a 1] [b 2] [c 3]
[a 1] [b 2] [c 3]
[a 1]

map::generic_reverse_iterator

Der Typ eines Reverse iterators für die Verwendung mit der generischen Schnittstelle für den Container.

Syntax

typedef Microsoft::VisualC::StlClr::Generic::
    ReverseRandomAccessIterator<generic_value>
    generic_reverse_iterator;

Hinweise

Der Typ beschreibt einen generischen Reverse iterator, der mit der generischen Schnittstelle für diese Vorlagencontainerklasse verwendet werden kann.

Beispiel

// cliext_map_generic_reverse_iterator.cpp
// compile with: /clr
#include <cliext/map>

typedef cliext::map<wchar_t, int> Mymap;
int main()
    {
    Mymap c1;
    c1.insert(Mymap::make_value(L'a', 1));
    c1.insert(Mymap::make_value(L'b', 2));
    c1.insert(Mymap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Mymap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // construct a generic container
    Mymap::generic_container^ gc1 = %c1;
    for each (Mymap::value_type elem in gc1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // get an element and display it
    Mymap::generic_reverse_iterator gcit = gc1->rbegin();
    Mymap::generic_value gcval = *gcit;
    System::Console::WriteLine("[{0} {1}] ", gcval->first, gcval->second);
    return (0);
    }

[a 1] [b 2] [c 3]
[a 1] [b 2] [c 3]
[c 3]

map::generic_value

Der Typ eines Elements für die Verwendung mit der generischen Schnittstelle für den Container.

Syntax

typedef GValue generic_value;

Hinweise

Der Typ beschreibt ein Objekt vom Typ GValue , das den gespeicherten Elementwert für die Verwendung mit der generischen Schnittstelle für diese Vorlagencontainerklasse beschreibt.

Beispiel

// cliext_map_generic_value.cpp
// compile with: /clr
#include <cliext/map>

typedef cliext::map<wchar_t, int> Mymap;
int main()
    {
    Mymap c1;
    c1.insert(Mymap::make_value(L'a', 1));
    c1.insert(Mymap::make_value(L'b', 2));
    c1.insert(Mymap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Mymap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // construct a generic container
    Mymap::generic_container^ gc1 = %c1;
    for each (Mymap::value_type elem in gc1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // get an element and display it
    Mymap::generic_iterator gcit = gc1->begin();
    Mymap::generic_value gcval = *gcit;
    System::Console::WriteLine("[{0} {1}] ", gcval->first, gcval->second);
    return (0);
    }

[a 1] [b 2] [c 3]
[a 1] [b 2] [c 3]
[a 1]

map::insert

Fügt Elemente hinzu.

Syntax

cliext::pair<iterator, bool> insert(value_type val);
iterator insert(iterator where, value_type val);
template<typename InIter>
    void insert(InIter first, InIter last);
void insert(System::Collections::Generic::IEnumerable<value_type>^ right);

Parameter

first
Anfang des einzufügenden Bereichs.

last
Ende des einzufügenden Bereichs.

right
Einzufügende Aufzählung.

val
Schlüsselwert, der eingefügt werden soll.

where
Wo im Container eingefügt werden soll (nur Hinweis).

Hinweise

Jede Elementfunktion fügt eine von den verbleibenden Operanden angegebene Sequenz ein.

Die erste Memberfunktion bemüht sich, ein Element mit Wert valeinzufügen und ein Wertepaar Xzurückgibt. Ist X.second "true", X.first wird das neu eingefügte Element festgelegt. Andernfalls X.first wird ein Element mit entsprechender Sortierung festgelegt, die bereits vorhanden ist und kein neues Element eingefügt wird. Sie verwenden es, um ein einzelnes Element einzufügen.

Die zweite Memberfunktion fügt ein Element mit Einem Wert valein, verwendet where als Hinweis (zur Verbesserung der Leistung), und gibt einen Iterator zurück, der das neu eingefügte Element angibt. Sie verwenden es, um ein einzelnes Element einzufügen, das sich möglicherweise neben einem Element befindet, das Sie kennen.

Die dritte Memberfunktion fügt die Sequenz [first, last) ein. Sie verwenden es, um null oder mehr Elemente einzufügen, die aus einer anderen Sequenz kopiert wurden.

Die vierte Memberfunktion fügt die durch die right. Sie verwenden sie, um eine von einem Enumerator beschriebene Sequenz einzufügen.

Jedes Elementeinfügung benötigt Zeit proportional zum Logarithmus der Anzahl der Elemente in der kontrollierten Sequenz. Das Einfügen kann in amortisierter Konstantenzeit erfolgen, jedoch mit einem Hinweis, der ein Element neben der Einfügemarke angibt.

Beispiel

// cliext_map_insert.cpp
// compile with: /clr
#include <cliext/map>

typedef cliext::map<wchar_t, int> Mymap;
typedef Mymap::pair_iter_bool Pairib;
int main()
    {
    Mymap c1;
    c1.insert(Mymap::make_value(L'a', 1));
    c1.insert(Mymap::make_value(L'b', 2));
    c1.insert(Mymap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Mymap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // insert a single value, unique and duplicate
// insert a single value, success and failure
    Pairib pair1 = c1.insert(Mymap::make_value(L'x', 24));
    System::Console::WriteLine("insert([L'x' 24]) = [[{0} {1}] {2}]",
        pair1.first->first, pair1.first->second, pair1.second);

    pair1 = c1.insert(Mymap::make_value(L'b', 2));
    System::Console::WriteLine("insert([L'b' 2]) = [[{0} {1}] {2}]",
        pair1.first->first, pair1.first->second, pair1.second);

    for each (Mymap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // insert a single value with hint
    Mymap::iterator it =
        c1.insert(c1.begin(), Mymap::make_value(L'y', 25));
    System::Console::WriteLine("insert(begin(), [L'y' 25]) = [{0} {1}]",
        it->first, it->second);
    for each (Mymap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // insert an iterator range
    Mymap c2;
    it = c1.end();
    c2.insert(c1.begin(), --it);
    for each (Mymap::value_type elem in c2)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // insert an enumeration
    Mymap c3;
    c3.insert(   // NOTE: cast is not needed
        (System::Collections::Generic::
            IEnumerable<Mymap::value_type>^)%c1);
    for each (Mymap::value_type elem in c3)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();
    return (0);
    }

[a 1] [b 2] [c 3]
insert([L'x' 24]) = [[x 24] True]
insert([L'b' 2]) = [[b 2] False]
[a 1] [b 2] [c 3] [x 24]
insert(begin(), [L'y' 25]) = [y 25]
[a 1] [b 2] [c 3] [x 24] [y 25]
[a 1] [b 2] [c 3] [x 24]
[a 1] [b 2] [c 3] [x 24] [y 25]

map::iterator

Der Typ eines Iterators für die gesteuerte Sequenz.

Syntax

typedef T1 iterator;

Hinweise

Der Typ beschreibt ein Objekt nicht angegebener Typs T1 , das als bidirektionaler Iterator für die kontrollierte Sequenz dienen kann.

Beispiel

// cliext_map_iterator.cpp
// compile with: /clr
#include <cliext/map>

typedef cliext::map<wchar_t, int> Mymap;
int main()
    {
    Mymap c1;
    c1.insert(Mymap::make_value(L'a', 1));
    c1.insert(Mymap::make_value(L'b', 2));
    c1.insert(Mymap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    Mymap::iterator it = c1.begin();
    for (; it != c1.end(); ++it)
        System::Console::Write("[{0} {1}] ", it->first, it->second);
    System::Console::WriteLine();
    return (0);
    }

[a 1] [b 2] [c 3]

map::key_comp

Kopiert den Sortierdelegat für zwei Schlüssel.

Syntax

key_compare^key_comp();

Hinweise

Die Memberfunktion gibt den Sortierdelegat zurück, der zum Sortieren der gesteuerten Sequenz verwendet wird. Sie verwenden es, um zwei Tasten zu vergleichen.

Beispiel

// cliext_map_key_comp.cpp
// compile with: /clr
#include <cliext/map>

typedef cliext::map<wchar_t, int> Mymap;
int main()
    {
    Mymap c1;
    Mymap::key_compare^ kcomp = c1.key_comp();

    System::Console::WriteLine("compare(L'a', L'a') = {0}",
        kcomp(L'a', L'a'));
    System::Console::WriteLine("compare(L'a', L'b') = {0}",
        kcomp(L'a', L'b'));
    System::Console::WriteLine("compare(L'b', L'a') = {0}",
        kcomp(L'b', L'a'));
    System::Console::WriteLine();

    // test a different ordering rule
    Mymap c2 = cliext::greater<wchar_t>();
    kcomp = c2.key_comp();

    System::Console::WriteLine("compare(L'a', L'a') = {0}",
        kcomp(L'a', L'a'));
    System::Console::WriteLine("compare(L'a', L'b') = {0}",
        kcomp(L'a', L'b'));
    System::Console::WriteLine("compare(L'b', L'a') = {0}",
        kcomp(L'b', L'a'));
    return (0);
    }

compare(L'a', L'a') = False
compare(L'a', L'b') = True
compare(L'b', L'a') = False

compare(L'a', L'a') = False
compare(L'a', L'b') = False
compare(L'b', L'a') = True

map::key_compare

Der Sortierdelegat für zwei Schlüssel.

Syntax

Microsoft::VisualC::StlClr::BinaryDelegate<GKey, GKey, bool>
    key_compare;

Hinweise

Der Typ ist ein Synonym für den Delegaten, der die Sortierung seiner Schlüsselargumente bestimmt.

Beispiel

// cliext_map_key_compare.cpp
// compile with: /clr
#include <cliext/map>

typedef cliext::map<wchar_t, int> Mymap;
int main()
    {
    Mymap c1;
    Mymap::key_compare^ kcomp = c1.key_comp();

    System::Console::WriteLine("compare(L'a', L'a') = {0}",
        kcomp(L'a', L'a'));
    System::Console::WriteLine("compare(L'a', L'b') = {0}",
        kcomp(L'a', L'b'));
    System::Console::WriteLine("compare(L'b', L'a') = {0}",
        kcomp(L'b', L'a'));
    System::Console::WriteLine();

    // test a different ordering rule
    Mymap c2 = cliext::greater<wchar_t>();
    kcomp = c2.key_comp();

    System::Console::WriteLine("compare(L'a', L'a') = {0}",
        kcomp(L'a', L'a'));
    System::Console::WriteLine("compare(L'a', L'b') = {0}",
        kcomp(L'a', L'b'));
    System::Console::WriteLine("compare(L'b', L'a') = {0}",
        kcomp(L'b', L'a'));
    return (0);
    }

compare(L'a', L'a') = False
compare(L'a', L'b') = True
compare(L'b', L'a') = False

compare(L'a', L'a') = False
compare(L'a', L'b') = False
compare(L'b', L'a') = True

map::key_type

Der Typ eines Sortierschlüssels.

Syntax

typedef Key key_type;

Hinweise

Der Type stellt ein Synonym für den Vorlagenparameter Keydar.

Beispiel

// cliext_map_key_type.cpp
// compile with: /clr
#include <cliext/map>

typedef cliext::map<wchar_t, int> Mymap;
int main()
    {
    Mymap c1;
    c1.insert(Mymap::make_value(L'a', 1));
    c1.insert(Mymap::make_value(L'b', 2));
    c1.insert(Mymap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]" using key_type
    for (Mymap::iterator it = c1.begin(); it != c1.end(); ++it)
        {   // store element in key_type object
        Mymap::key_type val = it->first;

        System::Console::Write("{0} ", val);
        }
    System::Console::WriteLine();
    return (0);
    }

a b c

map::lower_bound

Sucht den Anfang des Bereichs, der einem angegebenen Schlüssel entspricht.

Syntax

iterator lower_bound(key_type key);

Parameter

key
Der zu suchende Schlüsselwert.

Hinweise

Die Memberfunktion bestimmt das erste Element X in der gesteuerten Sequenz, das die entsprechende Reihenfolge keyaufweist. Wenn kein solches Element vorhanden ist, wird es zurückgegeben end(); andernfalls wird ein Iterator zurückgegeben, der dies Xangibt. Sie verwenden es, um den Anfang einer Abfolge von Elementen zu finden, die derzeit in der gesteuerten Sequenz vorhanden sind, die einem angegebenen Schlüssel entsprechen.

Beispiel

// cliext_map_lower_bound.cpp
// compile with: /clr
#include <cliext/map>

typedef cliext::map<wchar_t, int> Mymap;
int main()
    {
    Mymap c1;
    c1.insert(Mymap::make_value(L'a', 1));
    c1.insert(Mymap::make_value(L'b', 2));
    c1.insert(Mymap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Mymap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    System::Console::WriteLine("lower_bound(L'x')==end() = {0}",
        c1.lower_bound(L'x') == c1.end());

    Mymap::iterator it = c1.lower_bound(L'a');
    System::Console::WriteLine("*lower_bound(L'a') = [{0} {1}]",
        it->first, it->second);
    it = c1.lower_bound(L'b');
    System::Console::WriteLine("*lower_bound(L'b') = [{0} {1}]",
        it->first, it->second);
    return (0);
    }

[a 1] [b 2] [c 3]
lower_bound(L'x')==end() = True
*lower_bound(L'a') = [a 1]
*lower_bound(L'b') = [b 2]

map::make_value

Erstellt ein Wertobjekt.

Syntax

static value_type make_value(key_type key, mapped_type mapped);

Parameter

key
Schlüsselwert, der verwendet werden soll.

mapped
Zugeordneter Wert, nach dem gesucht werden soll.

Hinweise

Die Memberfunktion gibt ein value_type Objekt zurück, dessen Schlüssel und key dessen zugeordneter Wert ist mapped. Sie verwenden es, um ein Objekt zu verfassen, das für die Verwendung mit mehreren anderen Memberfunktionen geeignet ist.

Beispiel

// cliext_map_make_value.cpp
// compile with: /clr
#include <cliext/map>

typedef cliext::map<wchar_t, int> Mymap;
int main()
    {
    Mymap c1;
    c1.insert(Mymap::make_value(L'a', 1));
    c1.insert(Mymap::make_value(L'b', 2));
    c1.insert(Mymap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Mymap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();
    return (0);
    }

[a 1] [b 2] [c 3]

map::map

Erstellt ein container-Objekt.

Syntax

map();
explicit map(key_compare^ pred);
map(map<Key, Mapped>% right);
map(map<Key, Mapped>^ right);
template<typename InIter>
    mapmap(InIter first, InIter last);
template<typename InIter>
    map(InIter first, InIter last,
        key_compare^ pred);
map(System::Collections::Generic::IEnumerable<GValue>^ right);
map(System::Collections::Generic::IEnumerable<GValue>^ right,
    key_compare^ pred);

Parameter

first
Anfang des einzufügenden Bereichs.

last
Ende des einzufügenden Bereichs.

pred
Sortieren des Prädikats für die kontrollierte Sequenz.

right
Einzufügendes Objekt bzw. einzufügender Bereich.

Hinweise

Der Konstruktor:

map();

initialisiert die kontrollierte Sequenz ohne Elemente mit dem Standardreihenfolgen-Prädikat key_compare(). Sie verwenden es, um eine leere anfängliche kontrollierte Sequenz mit dem Standardreihenfolge-Prädikat anzugeben.

Der Konstruktor:

explicit map(key_compare^ pred);

initialisiert die kontrollierte Sequenz ohne Elemente mit dem Sortier-Prädikat pred. Sie verwenden es, um eine leere anfängliche kontrollierte Sequenz mit dem angegebenen Sortier-Prädikat anzugeben.

Der Konstruktor:

map(map<Key, Mapped>% right);

initialisiert die kontrollierte Sequenz mit der Sequenz [right.begin(), right.end()), mit dem Standardreihenfolgen-Prädikat. Sie verwenden es, um eine anfängliche kontrollierte Sequenz anzugeben, die eine Kopie der vom Objekt rightgesteuerten map Sequenz mit dem Standardreihenfolgen-Prädikat ist.

Der Konstruktor:

map(map<Key, Mapped>^ right);

initialisiert die kontrollierte Sequenz mit der Sequenz [right->begin(), right->end()), mit dem Standardreihenfolgen-Prädikat. Sie verwenden es, um eine anfängliche kontrollierte Sequenz anzugeben, die eine Kopie der vom Objekt rightgesteuerten map Sequenz mit dem Standardreihenfolgen-Prädikat ist.

Der Konstruktor:

template<typename InIter> map(InIter first, InIter last);

initialisiert die kontrollierte Sequenz mit der Sequenz [first, last), mit dem Standardreihenfolgen-Prädikat. Sie verwenden es, um die kontrollierte Sequenz zu einer Kopie einer anderen Sequenz mit dem Standardreihenfolge-Prädikat zu machen.

Der Konstruktor:

template<typename InIter> map(InIter first, InIter last, key_compare^ pred);

initialisiert die kontrollierte Sequenz mit der Sequenz [first, last), mit dem Sortier-Prädikat pred. Sie verwenden es, um die kontrollierte Sequenz zu einer Kopie einer anderen Sequenz mit dem angegebenen Sortier-Prädikat zu machen.

Der Konstruktor:

map(System::Collections::Generic::IEnumerable<Key>^ right);

initialisiert die kontrollierte Sequenz mit der vom Enumerator rightfestgelegten Sequenz mit dem Standardreihenfolgen-Prädikat. Sie verwenden es, um die kontrollierte Sequenz zu einer Kopie einer anderen Sequenz zu machen, die von einem Enumerator mit dem Standardreihenfolge-Prädikat beschrieben wird.

Der Konstruktor:

map(System::Collections::Generic::IEnumerable<Key>^ right, key_compare^ pred);

initialisiert die kontrollierte Sequenz mit der Sequenz, die vom Enumerator rightbestimmt wird, mit dem Sortier-Prädikat pred. Sie verwenden es, um die kontrollierte Sequenz zu einer Kopie einer anderen Sequenz zu machen, die von einem Enumerator mit dem angegebenen Sortier-Prädikat beschrieben wird.

Beispiel

// cliext_map_construct.cpp
// compile with: /clr
#include <cliext/map>

typedef cliext::map<wchar_t, int> Mymap;
int main()
    {
// construct an empty container
    Mymap c1;
    System::Console::WriteLine("size() = {0}", c1.size());

    c1.insert(Mymap::make_value(L'a', 1));
    c1.insert(Mymap::make_value(L'b', 2));
    c1.insert(Mymap::make_value(L'c', 3));
    for each (Mymap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // construct with an ordering rule
    Mymap c2 = cliext::greater_equal<wchar_t>();
    System::Console::WriteLine("size() = {0}", c2.size());

    c2.insert(c1.begin(), c1.end());
    for each (Mymap::value_type elem in c2)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // construct with an iterator range
    Mymap c3(c1.begin(), c1.end());
    for each (Mymap::value_type elem in c3)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // construct with an iterator range and an ordering rule
    Mymap c4(c1.begin(), c1.end(),
        cliext::greater_equal<wchar_t>());
    for each (Mymap::value_type elem in c4)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // construct with an enumeration
    Mymap c5(   // NOTE: cast is not needed
        (System::Collections::Generic::IEnumerable<
            Mymap::value_type>^)%c3);
    for each (Mymap::value_type elem in c5)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // construct with an enumeration and an ordering rule
    Mymap c6(   // NOTE: cast is not needed
        (System::Collections::Generic::IEnumerable<
            Mymap::value_type>^)%c3,
                cliext::greater_equal<wchar_t>());
    for each (Mymap::value_type elem in c6)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // construct by copying another container
    Mymap c7(c4);
    for each (Mymap::value_type elem in c7)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // construct by copying a container handle
    Mymap c8(%c3);
    for each (Mymap::value_type elem in c8)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();
    return (0);
    }

size() = 0
[a 1] [b 2] [c 3]
size() = 0
[c 3] [b 2] [a 1]
[a 1] [b 2] [c 3]
[c 3] [b 2] [a 1]
[a 1] [b 2] [c 3]
[c 3] [b 2] [a 1]
[c 3] [b 2] [a 1]
[a 1] [b 2] [c 3]

map::mapped_type

Der Typ eines zugeordneten Werts, der jedem Schlüssel zugeordnet ist.

Syntax

typedef Mapped mapped_type;

Hinweise

Der Type stellt ein Synonym für den Vorlagenparameter Mappeddar.

Beispiel

// cliext_map_mapped_type.cpp
// compile with: /clr
#include <cliext/map>

typedef cliext::map<wchar_t, int> Mymap;
int main()
    {
    Mymap c1;
    c1.insert(Mymap::make_value(L'a', 1));
    c1.insert(Mymap::make_value(L'b', 2));
    c1.insert(Mymap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]" using mapped_type
    for (Mymap::iterator it = c1.begin(); it != c1.end(); ++it)
        {   // store element in mapped_type object
        Mymap::mapped_type val = it->second;

        System::Console::Write("{0} ", val);
        }
    System::Console::WriteLine();
    return (0);
    }

1 2 3

map::operator=

Ersetzt die kontrollierte Sequenz.

Syntax

map<Key, Mapped>% operator=(map<Key, Mapped>% right);

Parameter

right
Der zu kopierende Container.

Hinweise

Der Memberoperator kopiert right in das Objekt und gibt dann zurück *this. Sie können ihn verwenden, um die kontrollierte Sequenz durch eine Kopie der kontrollierten Sequenz in right zu ersetzen.

Beispiel

// cliext_map_operator_as.cpp
// compile with: /clr
#include <cliext/map>

typedef cliext::map<wchar_t, int> Mymap;
int main()
    {
    Mymap c1;
    c1.insert(Mymap::make_value(L'a', 1));
    c1.insert(Mymap::make_value(L'b', 2));
    c1.insert(Mymap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Mymap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // assign to a new container
    Mymap c2;
    c2 = c1;
    // display contents " [a 1] [b 2] [c 3]"
    for each (Mymap::value_type elem in c2)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();
    return (0);
    }

[a 1] [b 2] [c 3]
[a 1] [b 2] [c 3]

map::operator[]

Ordnet einen Schlüssel dem zugeordneten zugeordneten Wert zu.

Syntax

mapped_type operator[](key_type key);

Parameter

key
Der zu suchende Schlüsselwert.

Hinweise

Die Memberfunktionen bemühen sich, ein Element mit entsprechender Reihenfolge keyzu finden. Wenn ein Wert gefunden wird, wird der zugeordnete zugeordnete Wert zurückgegeben. andernfalls wird der zugeordnete (Standard)zugeordnete Wert eingefügt value_type(key, mapped_type()) und zurückgegeben. Sie verwenden ihn, um einen zugeordneten Wert anhand des zugeordneten Schlüssels nachzuschlagen, oder um sicherzustellen, dass ein Eintrag für den Schlüssel vorhanden ist, wenn keine gefunden wird.

Beispiel

// cliext_map_operator_sub.cpp
// compile with: /clr
#include <cliext/map>

typedef cliext::map<wchar_t, int> Mymap;
int main()
    {
    Mymap c1;
    c1.insert(Mymap::make_value(L'a', 1));
    c1.insert(Mymap::make_value(L'b', 2));
    c1.insert(Mymap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Mymap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    System::Console::WriteLine("c1[{0}] = {1}",
        L'A', c1[L'A']);
    System::Console::WriteLine("c1[{0}] = {1}",
        L'b', c1[L'b']);

    // redisplay altered contents
    for each (Mymap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // alter mapped values and redisplay
    c1[L'A'] = 10;
    c1[L'c'] = 13;
    for each (Mymap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();
    return (0);
    }

[a 1] [b 2] [c 3]
c1[A] = 0
c1[b] = 2
[A 0] [a 1] [b 2] [c 3]
[A 10] [a 1] [b 2] [c 13]

map::rbegin

Legt den Anfang der umgekehrten kontrollierten Sequenz fest.

Syntax

reverse_iterator rbegin();

Hinweise

Die Memberfunktion gibt einen Umgekehrten Iterator zurück, der das letzte Element der gesteuerten Sequenz oder direkt hinter dem Anfang einer leeren Sequenz angibt. Daher wird die beginning umgekehrte Sequenz festgelegt. Sie verwenden es, um einen Iterator zu erhalten, der den current Anfang der kontrollierten Sequenz angibt, die in umgekehrter Reihenfolge angezeigt wird, aber sein Status kann sich ändern, wenn sich die Länge der kontrollierten Sequenz ändert.

Beispiel

// cliext_map_rbegin.cpp
// compile with: /clr
#include <cliext/map>

typedef cliext::map<wchar_t, int> Mymap;
int main()
    {
    Mymap c1;
    c1.insert(Mymap::make_value(L'a', 1));
    c1.insert(Mymap::make_value(L'b', 2));
    c1.insert(Mymap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Mymap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // inspect first two items in reversed sequence
    Mymap::reverse_iterator rit = c1.rbegin();
    System::Console::WriteLine("*rbegin() = [{0} {1}]",
        rit->first, rit->second);
    ++rit;
    System::Console::WriteLine("*++rbegin() = [{0} {1}]",
        rit->first, rit->second);
    return (0);
    }

[a 1] [b 2] [c 3]
*rbegin() = [c 3]
*++rbegin() = [b 2]

map::reference

Der Typ eines Verweises auf ein Element.

Syntax

typedef value_type% reference;

Hinweise

Der Typ beschreibt einen Verweis auf ein Element.

Beispiel

// cliext_map_reference.cpp
// compile with: /clr
#include <cliext/map>

typedef cliext::map<wchar_t, int> Mymap;
int main()
    {
    Mymap c1;
    c1.insert(Mymap::make_value(L'a', 1));
    c1.insert(Mymap::make_value(L'b', 2));
    c1.insert(Mymap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    Mymap::iterator it = c1.begin();
    for (; it != c1.end(); ++it)
        {   // get a reference to an element
        Mymap::reference ref = *it;
        System::Console::Write("[{0} {1}] ", ref->first, ref->second);
        }
    System::Console::WriteLine();
    return (0);
    }

[a 1] [b 2] [c 3]

map::rend

Legt das Ende der umgekehrten kontrollierten Sequenz fest.

Syntax

reverse_iterator rend();

Hinweise

Die Memberfunktion gibt einen Umgekehrten Iterator zurück, der unmittelbar über den Anfang der gesteuerten Sequenz verweist. Daher wird die end umgekehrte Sequenz festgelegt. Sie verwenden es, um einen Iterator zu erhalten, der das current Ende der kontrollierten Sequenz angibt, die in umgekehrter Reihenfolge angezeigt wird, aber sein Status kann sich ändern, wenn sich die Länge der kontrollierten Sequenz ändert.

Beispiel

// cliext_map_rend.cpp
// compile with: /clr
#include <cliext/map>

typedef cliext::map<wchar_t, int> Mymap;
int main()
    {
    Mymap c1;
    c1.insert(Mymap::make_value(L'a', 1));
    c1.insert(Mymap::make_value(L'b', 2));
    c1.insert(Mymap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Mymap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // inspect first two items in reversed sequence
    Mymap::reverse_iterator rit = c1.rend();
    --rit;
    --rit;
    System::Console::WriteLine("*-- --rend() = [{0} {1}]",
        rit->first, rit->second);
    ++rit;
    System::Console::WriteLine("*--rend() = [{0} {1}]",
        rit->first, rit->second);
    return (0);
    }

[a 1] [b 2] [c 3]
*-- --rend() = [b 2]
*--rend() = [a 1]

map::reverse_iterator

Der Typ eines umgekehrten Iterators für die gesteuerte Sequenz.

Syntax

typedef T3 reverse_iterator;

Hinweise

Der Typ beschreibt ein Objekt nicht angegebener Typs T3 , das als Umgekehrter Iterator für die kontrollierte Sequenz dienen kann.

Beispiel

// cliext_map_reverse_iterator.cpp
// compile with: /clr
#include <cliext/map>

typedef cliext::map<wchar_t, int> Mymap;
int main()
    {
    Mymap c1;
    c1.insert(Mymap::make_value(L'a', 1));
    c1.insert(Mymap::make_value(L'b', 2));
    c1.insert(Mymap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]" reversed
    Mymap::reverse_iterator rit = c1.rbegin();
    for (; rit != c1.rend(); ++rit)
        System::Console::Write("[{0} {1}] ", rit->first, rit->second);
    System::Console::WriteLine();
    return (0);
    }

[c 3] [b 2] [a 1]

map::size

Ermittelt die Anzahl von Elementen.

Syntax

size_type size();

Hinweise

Die Memberfunktion gibt die Länge der gesteuerten Sequenz zurück. Sie verwenden es, um die Anzahl der Elemente zu bestimmen, die sich derzeit in der kontrollierten Sequenz befindet. Wenn Sie sich nur darum kümmern, ob die Sequenz eine Nichtzerogröße aufweist, lesen Sie empty().

Beispiel

// cliext_map_size.cpp
// compile with: /clr
#include <cliext/map>

typedef cliext::map<wchar_t, int> Mymap;
int main()
    {
    Mymap c1;
    c1.insert(Mymap::make_value(L'a', 1));
    c1.insert(Mymap::make_value(L'b', 2));
    c1.insert(Mymap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Mymap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // clear the container and reinspect
    c1.clear();
    System::Console::WriteLine("size() = {0} after clearing", c1.size());

    // add elements and clear again
    c1.insert(Mymap::make_value(L'd', 4));
    c1.insert(Mymap::make_value(L'e', 5));
    System::Console::WriteLine("size() = {0} after adding 2", c1.size());
    return (0);
    }

[a 1] [b 2] [c 3]
size() = 0 after clearing
size() = 2 after adding 2

map::size_type

Der Typ eines Abstands mit Vorzeichen zwischen zwei Elementen.

Syntax

typedef int size_type;

Hinweise

Der Typ beschreibt eine nicht negative Elementanzahl.

Beispiel

// cliext_map_size_type.cpp
// compile with: /clr
#include <cliext/map>

typedef cliext::map<wchar_t, int> Mymap;
int main()
    {
    Mymap c1;
    c1.insert(Mymap::make_value(L'a', 1));
    c1.insert(Mymap::make_value(L'b', 2));
    c1.insert(Mymap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Mymap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // compute positive difference
    Mymap::size_type diff = 0;
    for (Mymap::iterator it = c1.begin(); it != c1.end(); ++it)
        ++diff;
    System::Console::WriteLine("end()-begin() = {0}", diff);
    return (0);
    }

[a 1] [b 2] [c 3]
end()-begin() = 3

map::swap

Vertauscht den Inhalt von zwei Containern.

Syntax

void swap(map<Key, Mapped>% right);

Parameter

right
Container für den Tausch von Inhalten.

Hinweise

Die Memberfunktion tauscht die kontrollierten Sequenzen zwischen this und right aus. Dies geschieht in konstanter Zeit und löst keine Ausnahmen aus. Sie verwenden es als schnelle Möglichkeit, den Inhalt von zwei Containern auszutauschen.

Beispiel

// cliext_map_swap.cpp
// compile with: /clr
#include <cliext/map>

typedef cliext::map<wchar_t, int> Mymap;
int main()
    {
    Mymap c1;
    c1.insert(Mymap::make_value(L'a', 1));
    c1.insert(Mymap::make_value(L'b', 2));
    c1.insert(Mymap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Mymap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // construct another container with repetition of values
    Mymap c2;
    c2.insert(Mymap::make_value(L'd', 4));
    c2.insert(Mymap::make_value(L'e', 5));
    c2.insert(Mymap::make_value(L'f', 6));
    for each (Mymap::value_type elem in c2)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // swap and redisplay
    c1.swap(c2);
    for each (Mymap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    for each (Mymap::value_type elem in c2)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();
    return (0);
    }

[a 1] [b 2] [c 3]
[d 4] [e 5] [f 6]
[d 4] [e 5] [f 6]
[a 1] [b 2] [c 3]

map::to_array

Kopiert die kontrollierte Sequenz in ein neues Array.

Syntax

cli::array<value_type>^ to_array();

Hinweise

Die Memberfunktion gibt ein Array zurück, das die kontrollierte Sequenz enthält. Sie verwenden es, um eine Kopie der kontrollierten Sequenz in Arrayform abzurufen.

Beispiel

// cliext_map_to_array.cpp
// compile with: /clr
#include <cliext/map>

typedef cliext::map<wchar_t, int> Mymap;
int main()
    {
    Mymap c1;
    c1.insert(Mymap::make_value(L'a', 1));
    c1.insert(Mymap::make_value(L'b', 2));
    c1.insert(Mymap::make_value(L'c', 3));

    // copy the container and modify it
    cli::array<Mymap::value_type>^ a1 = c1.to_array();

    c1.insert(Mymap::make_value(L'd', 4));
    for each (Mymap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // display the earlier array copy
    for each (Mymap::value_type elem in a1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();
    return (0);
    }

[a 1] [b 2] [c 3] [d 4]
[a 1] [b 2] [c 3]

map::upper_bound

Sucht das Ende des Bereichs, der einem angegebenen Schlüssel entspricht.

Syntax

iterator upper_bound(key_type key);

Parameter

key
Der zu suchende Schlüsselwert.

Hinweise

Die Memberfunktion bestimmt das letzte Element X in der kontrollierten Sequenz, das eine entsprechende Sortierung aufweist key. Wenn kein solches Element vorhanden ist oder wenn X es sich um das letzte Element in der kontrollierten Sequenz handelt, wird es zurückgegeben end(); andernfalls wird ein Iterator zurückgegeben, der das erste Element überschreitet X. Sie verwenden es, um das Ende einer Abfolge von Elementen zu finden, die derzeit in der kontrollierten Sequenz vorhanden sind, die einem angegebenen Schlüssel entsprechen.

Beispiel

// cliext_map_upper_bound.cpp
// compile with: /clr
#include <cliext/map>

typedef cliext::map<wchar_t, int> Mymap;
int main()
    {
    Mymap c1;
    c1.insert(Mymap::make_value(L'a', 1));
    c1.insert(Mymap::make_value(L'b', 2));
    c1.insert(Mymap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Mymap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    System::Console::WriteLine("upper_bound(L'x')==end() = {0}",
        c1.upper_bound(L'x') == c1.end());

    Mymap::iterator it = c1.upper_bound(L'a');
    System::Console::WriteLine("*upper_bound(L'a') = [{0} {1}]",
        it->first, it->second);
    it = c1.upper_bound(L'b');
    System::Console::WriteLine("*upper_bound(L'b') = [{0} {1}]",
        it->first, it->second);
    return (0);
    }

[a 1] [b 2] [c 3]
upper_bound(L'x')==end() = True
*upper_bound(L'a') = [b 2]
*upper_bound(L'b') = [c 3]

map::value_comp

Kopiert den Sortierdelegat für zwei Elementwerte.

Syntax

value_compare^ value_comp();

Hinweise

Die Memberfunktion gibt den Sortierdelegat zurück, der zum Sortieren der gesteuerten Sequenz verwendet wird. Sie verwenden es, um zwei Elementwerte zu vergleichen.

Beispiel

// cliext_map_value_comp.cpp
// compile with: /clr
#include <cliext/map>

typedef cliext::map<wchar_t, int> Mymap;
int main()
    {
    Mymap c1;
    Mymap::value_compare^ kcomp = c1.value_comp();

    System::Console::WriteLine("compare([L'a', 1], [L'a', 1]) = {0}",
        kcomp(Mymap::make_value(L'a', 1),
            Mymap::make_value(L'a', 1)));
    System::Console::WriteLine("compare([L'a', 1], [L'b', 2]) = {0}",
        kcomp(Mymap::make_value(L'a', 1),
            Mymap::make_value(L'b', 2)));
    System::Console::WriteLine("compare([L'b', 2], [L'a', 1]) = {0}",
        kcomp(Mymap::make_value(L'b', 2),
            Mymap::make_value(L'a', 1)));
    System::Console::WriteLine();
    return (0);
    }

compare([L'a', 1], [L'a', 1]) = False
compare([L'a', 1], [L'b', 2]) = True
compare([L'b', 2], [L'a', 1]) = False

map::value_compare

Der Sortierdelegat für zwei Elementwerte.

Syntax

Microsoft::VisualC::StlClr::BinaryDelegate<generic_value, generic_value, bool>
    value_compare;

Hinweise

Der Typ ist ein Synonym für den Delegaten, der die Sortierung seiner Wertargumente bestimmt.

Beispiel

// cliext_map_value_compare.cpp
// compile with: /clr
#include <cliext/map>

typedef cliext::map<wchar_t, int> Mymap;
int main()
    {
    Mymap c1;
    Mymap::value_compare^ kcomp = c1.value_comp();

    System::Console::WriteLine("compare([L'a', 1], [L'a', 1]) = {0}",
        kcomp(Mymap::make_value(L'a', 1),
            Mymap::make_value(L'a', 1)));
    System::Console::WriteLine("compare([L'a', 1], [L'b', 2]) = {0}",
        kcomp(Mymap::make_value(L'a', 1),
            Mymap::make_value(L'b', 2)));
    System::Console::WriteLine("compare([L'b', 2], [L'a', 1]) = {0}",
        kcomp(Mymap::make_value(L'b', 2),
            Mymap::make_value(L'a', 1)));
    System::Console::WriteLine();
    return (0);
    }

compare([L'a', 1], [L'a', 1]) = False
compare([L'a', 1], [L'b', 2]) = True
compare([L'b', 2], [L'a', 1]) = False

map::value_type

Der Typ eines Elements.

Syntax

typedef generic_value value_type;

Hinweise

Der Typ ist ein Synonym für generic_value.

Beispiel

// cliext_map_value_type.cpp
// compile with: /clr
#include <cliext/map>

typedef cliext::map<wchar_t, int> Mymap;
int main()
    {
    Mymap c1;
    c1.insert(Mymap::make_value(L'a', 1));
    c1.insert(Mymap::make_value(L'b', 2));
    c1.insert(Mymap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]" using value_type
    for (Mymap::iterator it = c1.begin(); it != c1.end(); ++it)
        {   // store element in value_type object
        Mymap::value_type val = *it;
        System::Console::Write("[{0} {1}] ", val->first, val->second);
        }
    System::Console::WriteLine();
    return (0);
    }

[a 1] [b 2] [c 3]

operator!= (map) (STL/CLR)

Liste nicht gleich Vergleich.

Syntax

template<typename Key,
    typename Mapped>
    bool operator!=(map<Key, Mapped>% left,
        map<Key, Mapped>% right);

Parameter

left
Linker zu vergleichender Container.

right
Rechter zu vergleichender Container.

Hinweise

Die Operatorfunktion gibt zurück !(left == right). Sie verwenden es, um zu testen, ob left die Reihenfolge nicht identisch ist, wenn right die beiden Zuordnungen element nach Element verglichen werden.

Beispiel

// cliext_map_operator_ne.cpp
// compile with: /clr
#include <cliext/map>

typedef cliext::map<wchar_t, int> Mymap;
int main()
    {
    Mymap c1;
    c1.insert(Mymap::make_value(L'a', 1));
    c1.insert(Mymap::make_value(L'b', 2));
    c1.insert(Mymap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Mymap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // assign to a new container
    Mymap c2;
    c2.insert(Mymap::make_value(L'a', 1));
    c2.insert(Mymap::make_value(L'b', 2));
    c2.insert(Mymap::make_value(L'd', 4));

    // display contents " [a 1] [b 2] [d 4]"
    for each (Mymap::value_type elem in c2)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    System::Console::WriteLine("[a b c] != [a b c] is {0}",
        c1 != c1);
    System::Console::WriteLine("[a b c] != [a b d] is {0}",
        c1 != c2);
    return (0);
    }

[a 1] [b 2] [c 3]
[a 1] [b 2] [d 4]
[a b c] != [a b c] is False
[a b c] != [a b d] is True

operator< (Karte)

Liste kleiner als vergleich.

Syntax

template<typename Key,
    typename Mapped>
    bool operator<(map<Key, Mapped>% left,
        map<Key, Mapped>% right);

Parameter

left
Linker zu vergleichender Container.

right
Rechter zu vergleichender Container.

Hinweise

Die Operatorfunktion gibt true zurück, wenn, für die niedrigste Positioni, für die !(right[i] < left[i]) sie auch wahr ist.left[i] < right[i] Andernfalls wird left->size() < right->size()zurückgegeben. Verwenden Sie diesen Operator, um zu testen, ob left die beiden Zuordnungen nach right Element verglichen werden.

Beispiel

// cliext_map_operator_lt.cpp
// compile with: /clr
#include <cliext/map>

typedef cliext::map<wchar_t, int> Mymap;
int main()
    {
    Mymap c1;
    c1.insert(Mymap::make_value(L'a', 1));
    c1.insert(Mymap::make_value(L'b', 2));
    c1.insert(Mymap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Mymap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // assign to a new container
    Mymap c2;
    c2.insert(Mymap::make_value(L'a', 1));
    c2.insert(Mymap::make_value(L'b', 2));
    c2.insert(Mymap::make_value(L'd', 4));

    // display contents " [a 1] [b 2] [d 4]"
    for each (Mymap::value_type elem in c2)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    System::Console::WriteLine("[a b c] < [a b c] is {0}",
        c1 < c1);
    System::Console::WriteLine("[a b c] < [a b d] is {0}",
        c1 < c2);
    return (0);
    }

[a 1] [b 2] [c 3]
[a 1] [b 2] [d 4]
[a b c] < [a b c] is False
[a b c] < [a b d] is True

operator<= (Karte)

Liste kleiner oder gleicher Vergleich.

Syntax

template<typename Key,
    typename Mapped>
    bool operator<=(map<Key, Mapped>% left,
        map<Key, Mapped>% right);

Parameter

left
Linker zu vergleichender Container.

right
Rechter zu vergleichender Container.

Hinweise

Die Operatorfunktion gibt zurück !(right < left). Sie verwenden es, um zu testen, ob left das Element nach Element nicht sortiert right wird, wenn die beiden Zuordnungen nach Element verglichen werden.

Beispiel

// cliext_map_operator_le.cpp
// compile with: /clr
#include <cliext/map>

typedef cliext::map<wchar_t, int> Mymap;
int main()
    {
    Mymap c1;
    c1.insert(Mymap::make_value(L'a', 1));
    c1.insert(Mymap::make_value(L'b', 2));
    c1.insert(Mymap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Mymap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // assign to a new container
    Mymap c2;
    c2.insert(Mymap::make_value(L'a', 1));
    c2.insert(Mymap::make_value(L'b', 2));
    c2.insert(Mymap::make_value(L'd', 4));

    // display contents " [a 1] [b 2] [d 4]"
    for each (Mymap::value_type elem in c2)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    System::Console::WriteLine("[a b c] <= [a b c] is {0}",
        c1 <= c1);
    System::Console::WriteLine("[a b d] <= [a b c] is {0}",
        c2 <= c1);
    return (0);
    }

[a 1] [b 2] [c 3]
[a 1] [b 2] [d 4]
[a b c] <= [a b c] is True
[a b d] <= [a b c] is False

operator== (Karte)

Vergleich gleich auflisten.

Syntax

template<typename Key,
    typename Mapped>
    bool operator==(map<Key, Mapped>% left,
        map<Key, Mapped>% right);

Parameter

left
Linker zu vergleichender Container.

right
Rechter zu vergleichender Container.

Hinweise

Die Operatorfunktion gibt "true" nur zurück, wenn die sequenzen gesteuert werden left und right dieselbe Länge aufweisen und für jede Position i, left[i] == right[i]. Sie verwenden es, um zu testen, ob left die Reihenfolge wie beim Vergleich der beiden Zuordnungen nach Element identisch right ist.

Beispiel

// cliext_map_operator_eq.cpp
// compile with: /clr
#include <cliext/map>

typedef cliext::map<wchar_t, int> Mymap;
int main()
    {
    Mymap c1;
    c1.insert(Mymap::make_value(L'a', 1));
    c1.insert(Mymap::make_value(L'b', 2));
    c1.insert(Mymap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Mymap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // assign to a new container
    Mymap c2;
    c2.insert(Mymap::make_value(L'a', 1));
    c2.insert(Mymap::make_value(L'b', 2));
    c2.insert(Mymap::make_value(L'd', 4));

    // display contents " [a 1] [b 2] [d 4]"
    for each (Mymap::value_type elem in c2)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    System::Console::WriteLine("[a b c] == [a b c] is {0}",
        c1 == c1);
    System::Console::WriteLine("[a b c] == [a b d] is {0}",
        c1 == c2);
    return (0);
    }

[a 1] [b 2] [c 3]
[a 1] [b 2] [d 4]
[a b c] == [a b c] is True
[a b c] == [a b d] is False

operator> (Karte)

Liste größer als vergleich.

Syntax

template<typename Key,
    typename Mapped>
    bool operator>(map<Key, Mapped>% left,
        map<Key, Mapped>% right);

Parameter

left
Linker zu vergleichender Container.

right
Rechter zu vergleichender Container.

Hinweise

Die Operatorfunktion gibt zurück right < left. Sie verwenden es, um zu testen, ob left nach dem right Vergleich der beiden Zuordnungen Element nach Element sortiert wird.

Beispiel

// cliext_map_operator_gt.cpp
// compile with: /clr
#include <cliext/map>

typedef cliext::map<wchar_t, int> Mymap;
int main()
    {
    Mymap c1;
    c1.insert(Mymap::make_value(L'a', 1));
    c1.insert(Mymap::make_value(L'b', 2));
    c1.insert(Mymap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Mymap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // assign to a new container
    Mymap c2;
    c2.insert(Mymap::make_value(L'a', 1));
    c2.insert(Mymap::make_value(L'b', 2));
    c2.insert(Mymap::make_value(L'd', 4));

    // display contents " [a 1] [b 2] [d 4]"
    for each (Mymap::value_type elem in c2)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    System::Console::WriteLine("[a b c] > [a b c] is {0}",
        c1 > c1);
    System::Console::WriteLine("[a b d] > [a b c] is {0}",
        c2 > c1);
    return (0);
    }

[a 1] [b 2] [c 3]
[a 1] [b 2] [d 4]
[a b c] > [a b c] is False
[a b d] > [a b c] is True

operator>= (Karte)

Liste größer oder gleich vergleich.

Syntax

template<typename Key,
    typename Mapped>
    bool operator>=(map<Key, Mapped>% left,
        map<Key, Mapped>% right);

Parameter

left
Linker zu vergleichender Container.

right
Rechter zu vergleichender Container.

Hinweise

Die Operatorfunktion gibt zurück !(left < right). Sie verwenden es, um zu testen, ob left die beiden Zuordnungen nach Element nicht sortiert right werden.

Beispiel

// cliext_map_operator_ge.cpp
// compile with: /clr
#include <cliext/map>

typedef cliext::map<wchar_t, int> Mymap;
int main()
    {
    Mymap c1;
    c1.insert(Mymap::make_value(L'a', 1));
    c1.insert(Mymap::make_value(L'b', 2));
    c1.insert(Mymap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Mymap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // assign to a new container
    Mymap c2;
    c2.insert(Mymap::make_value(L'a', 1));
    c2.insert(Mymap::make_value(L'b', 2));
    c2.insert(Mymap::make_value(L'd', 4));

    // display contents " [a 1] [b 2] [d 4]"
    for each (Mymap::value_type elem in c2)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    System::Console::WriteLine("[a b c] >= [a b c] is {0}",
        c1 >= c1);
    System::Console::WriteLine("[a b c] >= [a b d] is {0}",
        c1 >= c2);
    return (0);
    }

[a 1] [b 2] [c 3]
[a 1] [b 2] [d 4]
[a b c] >= [a b c] is True
[a b c] >= [a b d] is False