`map` (STL/CLR)

Artykuł
04/03/2023

Klasa szablonu opisuje obiekt, który kontroluje różną długość sekwencji elementów, które mają dostęp dwukierunkowy. Kontener map służy do zarządzania sekwencją elementów jako (prawie) uporządkowanym drzewem węzłów, z których każdy przechowuje jeden element. Element składa się z klucza służącego do zamawiania sekwencji i zamapowanej wartości, która przechodzi przez przejazd.

W poniższym GValue opisie jest taka sama jak:

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

gdzie:

GKey jest taki sam jak Key , chyba że ten ostatni jest typem ref, w takim przypadku jest to Key^

GMapped jest taki sam jak Mapped , chyba że ten ostatni jest typem ref, w takim przypadku jest to Mapped^

Składnia

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>
    { ..... };

Parametry

Key
Typ kluczowego składnika elementu w kontrolowanej sekwencji.

Mapped
Typ innego składnika elementu w kontrolowanej sekwencji.

Wymagania

Nagłówek:<cliext/map>

Obszaru nazw:cliext

Deklaracje

Definicja typu	opis
`map::const_iterator`	Typ iteratora stałego dla kontrolowanej sekwencji.
`map::const_reference`	Typ stałego odwołania do elementu.
`map::const_reverse_iterator`	Typ iteratora stałej odwrotnej dla kontrolowanej sekwencji.
`map::difference_type`	Typ (ewentualnie podpisanej) odległości między dwoma elementami.
`map::generic_container`	Typ interfejsu ogólnego dla kontenera.
`map::generic_iterator`	Typ iteratora dla interfejsu ogólnego dla kontenera.
`map::generic_reverse_iterator`	Typ iteratora odwrotnego dla interfejsu ogólnego dla kontenera.
`map::generic_value`	Typ elementu dla interfejsu ogólnego kontenera.
`map::iterator`	Typ iteratora dla kontrolowanej sekwencji.
`map::key_compare`	Delegat porządkowania dla dwóch kluczy.
`map::key_type`	Typ klucza sortowania.
`map::mapped_type`	Typ zamapowanej wartości skojarzonej z każdym kluczem.
`map::reference`	Typ odwołania do elementu.
`map::reverse_iterator`	Typ iteratora odwrotnego dla kontrolowanej sekwencji.
`map::size_type`	Typ odległości (nieujemnej) między dwoma elementami.
`map::value_compare`	Delegat porządkowania dla dwóch wartości elementów.
`map::value_type`	Typ elementu.

Funkcja składowa	opis
`map::begin`	Określa początek kontrolowanej sekwencji.
`map::clear`	Usuwa wszystkie elementy.
`map::count`	Zlicza elementy pasujące do określonego klucza.
`map::empty`	Sprawdza, czy nie ma żadnych elementów.
`map::end`	Określa koniec kontrolowanej sekwencji.
`map::equal_range`	Wyszukuje zakres, który odpowiada określonemu kluczowi.
`map::erase`	Usuwa elementy z określonych pozycji.
`map::find`	Wyszukuje element, który odpowiada określonemu kluczowi.
`map::insert`	Dodaje elementy.
`map::key_comp`	Kopiuje delegata porządkowania dla dwóch kluczy.
`map::lower_bound`	Znajduje początek zakresu, który pasuje do określonego klucza.
`map::make_value`	Tworzy obiekt wartości.
`map::map`	Konstruuje obiekt kontenera.
`map::rbegin`	Wyznacza początek odwróconej kontrolowanej sekwencji.
`map::rend`	Wyznacza koniec odwróconej kontrolowanej sekwencji.
`map::size`	Liczy liczbę elementów.
`map::swap`	Zamienia zawartości dwóch kontenerów.
`map::to_array`	Kopiuje kontrolowaną sekwencję do nowej tablicy.
`map::upper_bound`	Znajduje koniec zakresu, który pasuje do określonego klucza.
`map::value_comp`	Kopiuje delegata porządkowania dla dwóch wartości elementów.

Operator	opis
`map::operator=`	Zastępuje kontrolowaną sekwencję.
`map::operator[]`	Mapy klucz do skojarzonej zmapowanej wartości.
`operator!=` (mapa)	Określa, czy `map` obiekt nie jest równy innemu `map` obiektowi.
`operator<` (mapa)	Określa, czy `map` obiekt jest mniejszy niż inny `map` obiekt.
`operator<=` (mapa)	Określa, czy `map` obiekt jest mniejszy lub równy innemu `map` obiektowi.
`operator==` (mapa)	Określa, czy `map` obiekt jest równy innemu `map` obiektowi.
`operator>` (mapa)	Określa, czy `map` obiekt jest większy niż inny `map` obiekt.
`operator>=` (mapa)	Określa, czy `map` obiekt jest większy lub równy innemu `map` obiektowi.

Interfejsy

Interfejs	opis
ICloneable	Duplikuj obiekt.
IEnumerable	Sekwencja elementów.
ICollection	Zachowaj grupę elementów.
IEnumerable<T>	Sekwencjonowanie przez wpisane elementy.
ICollection<T>	Zachowaj grupę wpisanych elementów.
IDictionary<TKey,TValue>	Zachowaj grupę par {key, value}.
`ITree<Key, Value>`	Obsługa ogólnego kontenera.

Uwagi

Obiekt przydziela i zwalnia magazyn dla sekwencji, która kontroluje jako poszczególne węzły. Wstawia elementy do (prawie) zrównoważonego drzewa, które jest uporządkowane przez zmianę łączy między węzłami, nigdy przez skopiowanie zawartości jednego węzła do innego. Oznacza to, że można swobodnie wstawiać i usuwać elementy bez zakłócania pozostałych elementów.

Obiekt porządkuje sekwencję sterując nią przez wywołanie przechowywanego obiektu delegata typu map::key_compare. Podczas konstruowania mapy można określić przechowywany obiekt delegata; Jeśli nie określisz obiektu delegata, wartością domyślną jest porównanie operator<(key_type, key_type). Uzyskujesz dostęp do tego przechowywanego obiektu, wywołując funkcję map::key_compskładową .

Taki obiekt delegata musi narzucić ścisłe słabe porządkowanie kluczy typu map::key_type. Oznacza to, że dla dwóch kluczy X i Y:

key_comp()(X, Y) Zwraca ten sam wynik logiczny dla każdego wywołania.

Jeśli key_comp()(X, Y) wartość ma wartość true, key_comp()(Y, X) to musi być fałsz.

Jeśli key_comp()(X, Y) to prawda, mówi się, X że należy zamówić przed Y.

Jeśli !key_comp()(X, Y) && !key_comp()(Y, X) to prawda, to X i Y mówi się, że mają równoważne kolejność.

W przypadku każdego elementu X , który poprzedza Y się w kontrolowanej sekwencji, key_comp()(Y, X) jest false. (W przypadku domyślnego obiektu delegata klucze nigdy nie zmniejszają wartości). W przeciwieństwie do mapy klas szablonu obiekt klasy map szablonu nie wymaga, aby klucze dla wszystkich elementów są unikatowe. (Co najmniej dwa klucze mogą mieć równoważną kolejność).

Każdy element zawiera oddzielny klucz i zamapowany wartość. Sekwencja jest reprezentowana w sposób umożliwiający wyszukiwanie, wstawianie i usuwanie dowolnego elementu w czasie logarytmicznych. Oznacza to, że liczba operacji jest proporcjonalna do logarytmu liczby elementów w sekwencji. Ponadto wstawienie elementu powoduje unieważnienie żadnych iteratorów i usunięcie elementu unieważnia tylko te iteratory wskazujące na usunięty element.

Obiekt map obsługuje iteratory dwukierunkowe, co oznacza, że można przejść do sąsiednich elementów, biorąc pod uwagę iterator, który wyznacza element w kontrolowanej sekwencji. Specjalny węzeł główny odpowiada iteratorowi zwróconego przez end()element . Można dekrementować ten iterator, aby uzyskać dostęp do ostatniego elementu w kontrolowanej sekwencji, jeśli istnieje. Można zwiększać iterator, aby uzyskać dostęp do węzła map głównego, a następnie porównać wartość równą end(). Ale nie można wyłusić iteratora zwróconego przez end().

Nie można odwoływać się bezpośrednio do map elementu, biorąc pod uwagę jego położenie liczbowe. Wymaga to iteratora dostępu losowego.

Iterator map przechowuje dojście do skojarzonego map z nim węzła, co z kolei przechowuje dojście do skojarzonego kontenera. Iteratory można używać tylko ze skojarzonymi obiektami kontenera. map Iterator pozostaje prawidłowy tak długo, jak skojarzony map z nim węzeł jest skojarzony z niektórymi mapami. Co więcej, prawidłowy iterator jest wyłuskiwalny. Można go użyć, aby uzyskać dostęp do lub zmienić wartość elementu, którą wyznaczy, tak długo, jak nie jest równa end().

Wymazywanie lub usuwanie elementu wywołuje destruktor dla jego przechowywanej wartości. Zniszczenie kontenera spowoduje usunięcie wszystkich elementów. W związku z tym kontener, którego typ elementu jest klasą ref, gwarantuje, że żadne elementy nie przeżyją kontenera. Jednak kontener uchwytów nie niszczy swoich elementów.

Członkowie

`map::begin`

Określa początek kontrolowanej sekwencji.

Składnia

iterator begin();

Uwagi

Funkcja składowa zwraca iterator dwukierunkowy, który wyznacza pierwszy element kontrolowanej sekwencji lub tuż poza końcem pustej sekwencji. Służy do uzyskania iteratora, który wyznacza current początek kontrolowanej sekwencji, ale jego stan może ulec zmianie, jeśli długość kontrolowanej sekwencji ulegnie zmianie.

Przykład

// 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`

Usuwa wszystkie elementy.

Składnia

void clear();

Uwagi

Funkcja składowa skutecznie wywołuje funkcję erase(begin(), end()). Służy do zapewnienia, że kontrolowana sekwencja jest pusta.

Przykład

// 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`

Typ iteratora stałego dla kontrolowanej sekwencji.

Składnia

typedef T2 const_iterator;

Uwagi

Typ opisuje obiekt nieokreślonego typu T2 , który może służyć jako stały iterator dwukierunkowy dla kontrolowanej sekwencji.

Przykład

// 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`

Typ stałego odwołania do elementu.

Składnia

typedef value_type% const_reference;

Uwagi

Typ opisuje stałe odwołanie do elementu.

Przykład

// 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`

Typ iteratora stałej odwrotnej dla kontrolowanej sekwencji.

Składnia

typedef T4 const_reverse_iterator;

Uwagi

Typ opisuje obiekt nieokreślonego typu T4 , który może służyć jako stały iterator odwrotny dla kontrolowanej sekwencji.

Przykład

// 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`

Wyszukuje liczbę elementów pasujących do określonego klucza.

Składnia

size_type count(key_type key);

Parametry

key
Wartość klucza do wyszukania.

Uwagi

Funkcja składowa zwraca liczbę elementów w kontrolowanej sekwencji, które mają równoważną kolejność z key. Służy do określania liczby elementów aktualnie w kontrolowanej sekwencji zgodnej z określonym kluczem.

Przykład

// 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`

Typy podpisanej odległości między dwoma elementami.

Składnia

typedef int difference_type;

Uwagi

Typ opisuje prawdopodobnie ujemną liczbę elementów.

Przykład

// 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`

Sprawdza, czy nie ma żadnych elementów.

Składnia

bool empty();

Uwagi

Funkcja składowa zwraca wartość true dla pustej kontrolowanej sekwencji. Jest to odpowiednik size() == 0elementu . Służy do testowania, czy element map jest pusty.

Przykład

// 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`

Określa koniec kontrolowanej sekwencji.

Składnia

iterator end();

Uwagi

Funkcja składowa zwraca iterator dwukierunkowy, który wskazuje tuż poza koniec kontrolowanej sekwencji. Służy do uzyskania iteratora, który wyznacza koniec kontrolowanej sekwencji; jego stan nie zmienia się, jeśli długość kontrolowanej sekwencji ulegnie zmianie.

Przykład

// 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`

Wyszukuje zakres, który odpowiada określonemu kluczowi.

Składnia

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

Parametry

key
Wartość klucza do wyszukania.

Uwagi

Funkcja składowa zwraca parę iteratorów cliext::pair<iterator, iterator>(lower_bound(key), upper_bound(key)). Służy do określania zakresu elementów aktualnie w kontrolowanej sekwencji zgodnej z określonym kluczem.

Przykład

// 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`

Usuwa elementy z określonych pozycji.

Składnia

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

Parametry

first
Początek zakresu do wymazywania.

key
Wartość klucza do wymazywania.

last
Koniec zakresu do wymazywania.

where
Element do wymazywania.

Uwagi

Pierwsza funkcja składowa usuwa element kontrolowanej sekwencji wskazywanej przez whereelement i zwraca iterator, który wyznacza pierwszy element pozostały poza usuniętym elementem lub end() jeśli taki element nie istnieje. Służy do usuwania pojedynczego elementu.

Druga funkcja składowa usuwa elementy kontrolowanej sekwencji w zakresie [first, last), i zwraca iterator, który wyznacza pierwszy element pozostały poza żadnymi usuniętymi elementami lub end() jeśli taki element nie istnieje. Służy do usuwania zera lub większej liczby ciągłych elementów.

Trzecia funkcja składowa usuwa dowolny element kontrolowanej sekwencji, którego klucz ma równoważne kolejność do key, i zwraca liczbę usuniętych elementów. Służy do usuwania i liczenia wszystkich elementów pasujących do określonego klucza.

Wymazywanie każdego elementu wymaga czasu proporcjonalnego do logarytmu liczby elementów w kontrolowanej sekwencji.

Przykład

// 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`

Wyszukuje element, który odpowiada określonemu kluczowi.

Składnia

iterator find(key_type key);

Parametry

key
Wartość klucza do wyszukania.

Uwagi

Jeśli co najmniej jeden element w kontrolowanej sekwencji ma równoważną kolejność z key, funkcja składowa zwraca iterator wyznaczający jeden z tych elementów; w przeciwnym razie zwraca wartość end(). Służy do lokalizowania elementu aktualnie w kontrolowanej sekwencji zgodnej z określonym kluczem.

Przykład

// 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`

Typ interfejsu ogólnego dla kontenera.

Składnia

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

Uwagi

Typ opisuje ogólny interfejs dla tej klasy kontenera szablonu.

Przykład

// 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`

Typ iteratora do użycia z interfejsem ogólnym kontenera.

Składnia

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

Uwagi

Typ opisuje iterator ogólny, który może być używany z interfejsem ogólnym dla tej klasy kontenera szablonu.

Przykład

// 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`

Typ iteratora odwrotnego do użycia z interfejsem ogólnym kontenera.

Składnia

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

Uwagi

Typ opisuje ogólny iterator odwrotny, który może być używany z interfejsem ogólnym dla tej klasy kontenera szablonu.

Przykład

// 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`

Typ elementu do użycia z interfejsem ogólnym kontenera.

Składnia

typedef GValue generic_value;

Uwagi

Typ opisuje obiekt typu GValue , który opisuje przechowywaną wartość elementu do użycia z interfejsem ogólnym dla tej klasy kontenera szablonu.

Przykład

// 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`

Dodaje elementy.

Składnia

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

Parametry

first
Początek zakresu do wstawienia.

last
Koniec zakresu do wstawienia.

right
Wyliczenie do wstawienia.

val
Wartość klucza do wstawienia.

where
Gdzie w kontenerze do wstawienia (tylko wskazówka).

Uwagi

Każda z funkcji składowych wstawia sekwencję określoną przez pozostałe operandy.

Pierwsza funkcja składowa stara się wstawić element z wartością vali zwraca parę wartości X. Jeśli X.second ma wartość true, X.first wyznacza nowo wstawiony element; w przeciwnym razie X.first wyznacza element z równoważną kolejnością, która już istnieje i nie wstawia nowego elementu. Służy do wstawiania pojedynczego elementu.

Druga funkcja składowa wstawia element z wartością val, używając where jako wskazówki (w celu zwiększenia wydajności) i zwraca iterator, który wyznacza nowo wstawiony element. Służy do wstawiania pojedynczego elementu, który może znajdować się obok elementu, który znasz.

Trzecia funkcja składowa wstawia sekwencję [first, last). Służy do wstawiania zera lub większej liczby elementów skopiowanych z innej sekwencji.

Czwarta funkcja składowa wstawia sekwencję wyznaczoną rightprzez element . Służy do wstawiania sekwencji opisanej przez moduł wyliczający.

Każde wstawienie elementu wymaga czasu proporcjonalnego do logarytmu liczby elementów w kontrolowanej sekwencji. Wstawianie może wystąpić w zamortyzowanym stałym czasie, jednak biorąc pod uwagę wskazówkę, która wyznacza element obok punktu wstawiania.

Przykład

// 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`

Typ iteratora dla kontrolowanej sekwencji.

Składnia

typedef T1 iterator;

Uwagi

Typ opisuje obiekt nieokreślonego typu T1 , który może służyć jako iterator dwukierunkowy dla kontrolowanej sekwencji.

Przykład

// 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`

Kopiuje delegata porządkowania dla dwóch kluczy.

Składnia

key_compare^key_comp();

Uwagi

Funkcja składowa zwraca delegata porządkowania używanego do porządkowania kontrolowanej sekwencji. Służy do porównywania dwóch kluczy.

Przykład

// 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`

Delegat porządkowania dla dwóch kluczy.

Składnia

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

Uwagi

Typ jest synonimem delegata, który określa kolejność jego kluczowych argumentów.

Przykład

// 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`

Typ klucza sortowania.

Składnia

typedef Key key_type;

Uwagi

Typ jest synonimem parametru Keyszablonu .

Przykład

// 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`

Znajduje początek zakresu, który pasuje do określonego klucza.

Składnia

iterator lower_bound(key_type key);

Parametry

key
Wartość klucza do wyszukania.

Uwagi

Funkcja składowa określa pierwszy element X w kontrolowanej sekwencji, który ma równoważną kolejność do key. Jeśli taki element nie istnieje, zwraca end()wartość ; w przeciwnym razie zwraca iterator, który wyznacza Xwartość . Służy do lokalizowania początku sekwencji elementów aktualnie w kontrolowanej sekwencji, która jest zgodna z określonym kluczem.

Przykład

// 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`

Tworzy obiekt wartości.

Składnia

static value_type make_value(key_type key, mapped_type mapped);

Parametry

key
Wartość klucza do użycia.

mapped
Zamapowana wartość do wyszukania.

Uwagi

Funkcja składowa zwraca value_type obiekt, którego klucz jest key i którego zamapowana wartość to mapped. Służy do tworzenia obiektu odpowiedniego do użycia z kilkoma innymi funkcjami składowymi.

Przykład

// 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`

Konstruuje obiekt kontenera.

Składnia

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

Parametry

first
Początek zakresu do wstawienia.

last
Koniec zakresu do wstawienia.

pred
Kolejność predykatu dla kontrolowanej sekwencji.

right
Obiekt lub zakres do wstawienia.

Uwagi

Konstruktor:

map();

inicjuje kontrolowaną sekwencję bez elementów z domyślnym predykatem key_compare()porządkowania . Służy do określania pustej początkowej kontrolowanej sekwencji z domyślnym predykatem porządkowania.

Konstruktor:

explicit map(key_compare^ pred);

inicjuje kontrolowaną sekwencję bez elementów z predykatem predporządkowania . Służy do określania pustej początkowej kontrolowanej sekwencji z określonym predykatem porządkowania.

Konstruktor:

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

Inicjuje kontrolowaną sekwencję za pomocą sekwencji [right.begin(), right.end()), z domyślnym predykatem porządkowania. Służy do określania początkowej kontrolowanej sekwencji, która jest kopią sekwencji kontrolowanej przez map obiekt right, z domyślnym predykatem porządkowania.

Konstruktor:

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

Inicjuje kontrolowaną sekwencję za pomocą sekwencji [right->begin(), right->end()), z domyślnym predykatem porządkowania. Służy do określania początkowej kontrolowanej sekwencji, która jest kopią sekwencji kontrolowanej przez map obiekt right, z domyślnym predykatem porządkowania.

Konstruktor:

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

Inicjuje kontrolowaną sekwencję za pomocą sekwencji [first, last), z domyślnym predykatem porządkowania. Służy do tworzenia kontrolowanej sekwencji kopii innej sekwencji z domyślnym predykatem porządkowania.

Konstruktor:

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

inicjuje kontrolowaną sekwencję za pomocą sekwencji [first, last), z predykatem predporządkowania . Służy do tworzenia kontrolowanej sekwencji kopii innej sekwencji z określonym predykatem porządkowania.

Konstruktor:

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

inicjuje kontrolowaną sekwencję z sekwencją wyznaczoną przez moduł rightwyliczający , z domyślnym predykatem porządkowania. Służy do tworzenia kontrolowanej sekwencji kopii innej sekwencji opisanej przez moduł wyliczający z domyślnym predykatem porządkowania.

Konstruktor:

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

inicjuje kontrolowaną sekwencję z sekwencją wyznaczoną przez moduł rightwyliczający z predykatem predporządkowania . Służy do tworzenia kontrolowanej sekwencji kopii innej sekwencji opisanej przez moduł wyliczający z określonym predykatem porządkowania.

Przykład

// 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`

Typ mapowanej wartości skojarzonej z poszczególnymi kluczami.

Składnia

typedef Mapped mapped_type;

Uwagi

Typ jest synonimem parametru Mappedszablonu .

Przykład

// 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=`

Zastępuje kontrolowaną sekwencję.

Składnia

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

Parametry

right
Kontener do skopiowania.

Uwagi

Operator elementu członkowskiego kopiuje right do obiektu, a następnie zwraca wartość *this. Służy do zastępowania kontrolowanej sekwencji kopią kontrolowanej sekwencji w pliku right.

Przykład

// 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[]`

Mapy klucz do skojarzonej zmapowanej wartości.

Składnia

mapped_type operator[](key_type key);

Parametry

key
Wartość klucza do wyszukania.

Uwagi

Funkcje składowe dążą do znalezienia elementu z równoważną kolejnością na key. Jeśli ją znajdzie, zwraca skojarzona wartość mapowana; w przeciwnym razie wstawia value_type(key, mapped_type()) i zwraca skojarzona (domyślna) wartość mapowana. Służy do wyszukiwania zamapowanej wartości podanej w skojarzonym kluczu lub upewnienia się, że wpis istnieje dla klucza, jeśli nie zostanie znaleziony.

Przykład

// 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`

Wyznacza początek odwróconej kontrolowanej sekwencji.

Składnia

reverse_iterator rbegin();

Uwagi

Funkcja składowa zwraca iterator odwrotny, który wyznacza ostatni element kontrolowanej sekwencji lub tuż poza początkiem pustej sekwencji. W związku z tym wyznacza beginning sekwencję odwrotną. Służy do uzyskania iteratora, który wyznacza current początek kontrolowanej sekwencji widocznej w odwrotnej kolejności, ale jego stan może ulec zmianie, jeśli długość kontrolowanej sekwencji ulegnie zmianie.

Przykład

// 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`

Typ odwołania do elementu.

Składnia

typedef value_type% reference;

Uwagi

Typ opisuje odwołanie do elementu.

Przykład

// 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`

Wyznacza koniec odwróconej kontrolowanej sekwencji.

Składnia

reverse_iterator rend();

Uwagi

Funkcja składowa zwraca iterator odwrotny, który wskazuje tuż poza początkiem kontrolowanej sekwencji. W związku z tym wyznacza end sekwencję odwrotną. Służy do uzyskania iteratora, który wyznacza current koniec kontrolowanej sekwencji widocznej w odwrotnej kolejności, ale jego stan może ulec zmianie, jeśli długość kontrolowanej sekwencji ulegnie zmianie.

Przykład

// 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`

Typ iteratora odwrotnego dla kontrolowanej sekwencji.

Składnia

typedef T3 reverse_iterator;

Uwagi

Typ opisuje obiekt nieokreślonego typu T3 , który może służyć jako iterator odwrotny dla kontrolowanej sekwencji.

Przykład

// 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`

Liczy liczbę elementów.

Składnia

size_type size();

Uwagi

Funkcja składowa zwraca długość kontrolowanej sekwencji. Służy do określania liczby elementów aktualnie w kontrolowanej sekwencji. Jeśli chodzi o to, czy sekwencja ma rozmiar niezerowy, zobacz empty().

Przykład

// 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`

Typ odległości ze znakiem między dwoma elementami.

Składnia

typedef int size_type;

Uwagi

Typ opisuje nieujemną liczbę elementów.

Przykład

// 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`

Zamienia zawartości dwóch kontenerów.

Składnia

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

Parametry

right
Kontener do zamiany zawartości na.

Uwagi

Funkcja składowa zamienia kontrolowane sekwencje między this i right. Robi to w stałym czasie i nie zgłasza żadnych wyjątków. Służy ona jako szybki sposób wymiany zawartości dwóch kontenerów.

Przykład

// 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`

Kopiuje kontrolowaną sekwencję do nowej tablicy.

Składnia

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

Uwagi

Funkcja składowa zwraca tablicę zawierającą kontrolowaną sekwencję. Służy do uzyskiwania kopii kontrolowanej sekwencji w postaci tablicy.

Przykład

// 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`

Znajduje koniec zakresu, który pasuje do określonego klucza.

Składnia

iterator upper_bound(key_type key);

Parametry

key
Wartość klucza do wyszukania.

Uwagi

Funkcja składowa określa ostatni element X w kontrolowanej sekwencji, który ma równoważną kolejność do key. Jeśli taki element nie istnieje lub jeśli X jest ostatnim elementem w kontrolowanej sekwencji, zwraca wartość ; w przeciwnym razie zwraca end()iterator, który wyznacza pierwszy element poza X. Służy do lokalizowania końca sekwencji elementów aktualnie w kontrolowanej sekwencji, która jest zgodna z określonym kluczem.

Przykład

// 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`

Kopiuje delegata porządkowania dla dwóch wartości elementów.

Składnia

value_compare^ value_comp();

Uwagi

Funkcja składowa zwraca delegata porządkowania używanego do porządkowania kontrolowanej sekwencji. Służy do porównywania dwóch wartości elementów.

Przykład

// 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`

Delegat porządkowania dla dwóch wartości elementów.

Składnia

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

Uwagi

Typ jest synonimem delegata, który określa kolejność argumentów jego wartości.

Przykład

// 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`

Typ elementu.

Składnia

typedef generic_value value_type;

Uwagi

Typ jest synonimem .generic_value

Przykład

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

Lista nie jest równa porównania.

Składnia

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

Parametry

left
Pozostaw kontener do porównania.

right
Odpowiedni kontener do porównania.

Uwagi

Funkcja operatora zwraca !(left == right)wartość . Służy do testowania, czy left nie jest uporządkowane tak samo, jak right w przypadku, gdy obie mapy są porównywane element według elementu.

Przykład

// 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<` (mapa)

Wyświetl listę mniejszą niż porównanie.

Składnia

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

Parametry

left
Pozostaw kontener do porównania.

right
Odpowiedni kontener do porównania.

Uwagi

Funkcja operatora zwraca wartość true, jeśli dla najniższej pozycji i , dla której !(right[i] < left[i]) jest również prawdziwe, że left[i] < right[i]. W przeciwnym razie zwraca wartość left->size() < right->size(). Użyj tego operatora, aby sprawdzić, czy left jest uporządkowane przed right , gdy obie mapy są porównywane element według elementu.

Przykład

// 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<=` (mapa)

Wyświetl listę mniejszą niż lub równą porównanie.

Składnia

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

Parametry

left
Pozostaw kontener do porównania.

right
Odpowiedni kontener do porównania.

Uwagi

Funkcja operatora zwraca !(right < left)wartość . Służy do testowania, czy left nie są uporządkowane po right tym, jak obie mapy są porównywane element według elementu.

Przykład

// 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==` (mapa)

Wyświetl równe porównanie.

Składnia

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

Parametry

left
Pozostaw kontener do porównania.

right
Odpowiedni kontener do porównania.

Uwagi

Funkcja operatora zwraca wartość true tylko wtedy, gdy sekwencje kontrolowane przez left i right mają taką samą długość, a dla każdej pozycji i, left[i] == right[i]. Służy do testowania, czy left jest uporządkowana tak samo, jak right w przypadku porównywania dwóch map według elementu.

Przykład

// 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>` (mapa)

Wyświetl listę większą niż porównanie.

Składnia

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

Parametry

left
Pozostaw kontener do porównania.

right
Odpowiedni kontener do porównania.

Uwagi

Funkcja operatora zwraca right < leftwartość . Służy do testowania, czy left jest uporządkowane po right tym, jak obie mapy są porównywane element według elementu.

Przykład

// 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>=` (mapa)

Wyświetl więcej niż lub równe porównanie.

Składnia

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

Parametry

left
Pozostaw kontener do porównania.

right
Odpowiedni kontener do porównania.

Uwagi

Funkcja operatora zwraca !(left < right)wartość . Służy do testowania, czy left nie jest uporządkowana przed right rozpoczęciem porównywania dwóch map według elementu.

Przykład

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

map (STL/CLR)

Składnia

Parametry

Wymagania

Deklaracje

Interfejsy

Uwagi

Członkowie

map::begin

Składnia

Uwagi

Przykład

map::clear

Składnia

Uwagi

Przykład

map::const_iterator

Składnia

Uwagi

Przykład

map::const_reference

Składnia

Uwagi

Przykład

map::const_reverse_iterator

Składnia

Uwagi

Przykład

map::count

Składnia

Parametry

Uwagi

Przykład

map::difference_type

Składnia

Uwagi

Przykład

map::empty

Składnia

Uwagi

Przykład

map::end

Składnia

Uwagi

Przykład

map::equal_range

Składnia

Parametry

Uwagi

Przykład

map::erase

Składnia

Parametry

Uwagi

Przykład

map::find

Składnia

Parametry

Uwagi

Przykład

map::generic_container

Składnia

Uwagi

Przykład

map::generic_iterator

Składnia

Uwagi

Przykład

map::generic_reverse_iterator

Składnia

Uwagi

Przykład

map::generic_value

Składnia

Uwagi

Przykład

map::insert

Składnia

Parametry

Uwagi

`map` (STL/CLR)

`map::begin`

`map::clear`

`map::const_iterator`

`map::const_reference`

`map::const_reverse_iterator`

`map::count`

`map::difference_type`

`map::empty`

`map::end`

`map::equal_range`

`map::erase`

`map::find`

`map::generic_container`

`map::generic_iterator`

`map::generic_reverse_iterator`

`map::generic_value`

`map::insert`

`map::iterator`

`map::key_comp`

`map::key_compare`

`map::key_type`

`map::lower_bound`

`map::make_value`

`map::map`

`map::mapped_type`

`map::operator=`

`map::operator[]`

`map::rbegin`

`map::reference`

`map::rend`

`map::reverse_iterator`

`map::size`

`map::size_type`