`map` Klasa

Artykuł
06/16/2023

Używany do przechowywania i pobierania danych z kolekcji, w której każdy element jest parą, która ma zarówno wartość danych, jak i klucz sortowania. Wartość klucza jest unikatowa i jest używana do automatycznego sortowania danych.

Można bezpośrednio zmienić wartość elementu w mapie. Wartość klucza jest stałą i nie można jej zmienić. Zamiast tego, wartości kluczy skojarzone ze starymi elementami muszą zostać usunięte, a nowe wartości klucza muszą zostać wstawione dla nowych elementów.

Składnia

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

Parametry

Key
Typ danych klucza, który ma być przechowywany w obiekcie map.

Type
Typ danych elementu, który ma być przechowywany w obiekcie map.

Traits
Typ, który udostępnia obiekt funkcji, który może porównać dwie wartości elementu jako klucze sortowania, aby określić ich względną kolejność w obiekcie map. Ten argument jest opcjonalny, a predykat less<Key> binarny jest wartością domyślną.

W języku C++14 można włączyć heterogeniczne wyszukiwanie, określając std::less<> predykat, który nie ma parametrów typu. Aby uzyskać więcej informacji, zobacz Heterogeniczne wyszukiwanie w kontenerach asocjacyjnych.

Allocator
Typ reprezentujący przechowywany obiekt alokatora, który hermetyzuje szczegóły dotyczące alokacji mapy i dezalokacji pamięci. Ten argument jest opcjonalny, a wartość domyślna to allocator<pair<const Key, Type> >.

Uwagi

Klasa mapy biblioteki standardowej języka C++ to:

Kontenerem o zmiennym rozmiarze, który skutecznie pobiera wartości elementów na podstawie skojarzonych wartości klucza.
Odwracalny, ponieważ zapewnia dwukierunkowe iteratory do dostępu do jego elementów.
Posortowana, ponieważ jej elementy są uporządkowane według wartości kluczy zgodnie z określoną funkcją porównywania.
Unikatowy. ponieważ każdy z jego elementów musi mieć unikatowy klucz.
Kontenerem skojarzonych par, ponieważ jej wartości danych elementu różnią się od wartości klucza.
Szablon klasy, ponieważ zapewniana funkcja jest ogólna i niezależna od typu elementu lub klucza. Typy danych, których można użyć dla elementów i kluczy, są określane jako parametry w szablonie klasy wraz z funkcją porównywania oraz alokatorem.

Iterator dostarczany przez klasę mapy jest iteratorem dwukierunkowym, ale insert funkcje składowe klasy i map mają wersje, które przyjmują jako parametry szablonu słabszy iterator wejściowy, którego wymagania dotyczące funkcjonalności są mniejsze niż te gwarantowane przez klasę iteratorów dwukierunkowych. Pojęcia innych iteratorów są powiązane przez udoskonalenia w ich funkcjonalnościach. Każde pojęcie iteratora ma swój własny zestaw wymagań, a algorytmy, które z nim pracują, muszą być ograniczone przez te wymagania. Iterator danych wejściowych może zostać wyłuskany, aby odwołać się do jakiegoś obiektu, a także może być zwiększony do następnego iteratora w sekwencji.

Zalecamy, aby wybrać typ kontenera na podstawie rodzaju wyszukiwania i wstawiania, którego wymaga aplikacja. Kontenery asocjacyjne są zoptymalizowane dla operacji wyszukiwania, wstawiania i usuwania. Funkcje składowe, które jawnie obsługują te operacje, wykonują je w najgorszym przypadku proporcjonalnym do logarytmu liczby elementów w kontenerze. Wstawianie elementów nie unieważnia iteratorów, a usuwanie elementów unieważnia tylko te iteratory, które w szczególności wskazywały na usunięte elementy.

Zalecamy, aby kontener asocjacyjny z wyboru był mapą, gdy warunki, które kojarzą wartości z kluczami, są spełnione przez aplikację. Model dla tego rodzaju struktury jest uporządkowaną listą jednoznacznie występujących słów kluczowych mających skojarzone wartości ciągów, które zapewniają definicje. Jeśli słowo ma więcej niż jedną poprawną definicję, więc klucz nie jest unikatowy, multimapa będzie kontenerem do wyboru. Jeśli jest przechowywana tylko lista wyrazów, zestaw będzie odpowiednim kontenerem. Jeśli jest dozwolonych wiele wystąpień słów, to zestaw wielokrotny będzie odpowiedni.

Mapa porządkuje elementy, które kontroluje, wywołując przechowywany obiekt funkcji typu key_compare. Ten przechowywany obiekt jest funkcją porównania dostępną przez wywołanie key_comp metody . Ogólnie rzecz biorąc, wszystkie dwa podane elementy są porównywane w celu określenia, czy jeden jest mniejszy niż drugi, czy też jest równoważny. W miarę porównywania wszystkich elementów, tworzona jest uporządkowana sekwencja nierównoważnych elementów.

Uwaga

Funkcja porównywania jest predykatem binarnym, który wymusza ścisłe słabe porządkowanie w standardowym sensie matematycznym. Predykat binarny f(x,y) to obiekt funkcji, który ma dwa obiekty argumentów x i y oraz wartość true zwracaną lub false. Kolejność nałożona na zestaw jest ścisłym słabym uporządkowaniem, jeśli predykat binarny jest nieelastycznym, antysymmetrycznym i przechodniym, a jeśli równoważność jest przechodnia, gdzie dwa obiekty x i y są zdefiniowane jako równoważne, gdy oba obiekty f(x,y) i f(y,x) to false. Jeśli silniejszy warunek równości pomiędzy kluczami zastąpi ten równoważności, to porządkowanie będzie całkowite (w sensie, że wszystkie elementy są uporządkowane względem siebie), a dopasowane klucze będą od siebie nieodróżnialne.

W języku C++14 można włączyć heterogeniczne wyszukiwanie, określając std::less<> predykat lub std::greater<> bez parametrów typu. Aby uzyskać więcej informacji, zobacz Heterogeniczne wyszukiwanie w kontenerach asocjacyjnych.

Członkowie

Konstruktory

Nazwa/nazwisko	opis
`map`	Tworzy listę określonego rozmiaru lub z elementami określonej wartości lub z określoną `allocator` lub kopią innej mapy.

Typedefs

Nazwa/nazwisko	opis
`allocator_type`	Definicja typu dla `allocator` klasy dla obiektu mapy.
`const_iterator`	Definicja typu dla iteratora dwukierunkowego, który może odczytać `const` element w obiekcie `map`.
`const_pointer`	Definicja typu wskaźnika do `const` elementu na mapie.
`const_reference`	Definicja typu dla odwołania do elementu przechowywanego `const` na mapie na potrzeby odczytywania i wykonywania `const` operacji.
`const_reverse_iterator`	Typ, który udostępnia iterator dwukierunkowy, który może odczytywać dowolny `const` element w obiekcie `map`.
`difference_type`	Element typedef całkowitoliczbowy ze znakiem dla liczby elementów mapy w zakresie między elementami wskazywanymi przez iteratory.
`iterator`	Element typedef dla iteratora dwukierunkowego, który może odczytać lub zmodyfikować dowolny element w mapie.
`key_compare`	Definicja typu dla obiektu funkcji, który może porównać dwa klucze sortowania, aby określić względną kolejność dwóch elementów w obiekcie `map`.
`key_type`	Element typedef dla klucza sortowania przechowywanego w każdym elemencie mapy.
`mapped_type`	Element typedef dla danych przechowywanych w każdym elemencie mapy.
`pointer`	Definicja typu wskaźnika do `const` elementu na mapie.
`reference`	Element typedef dla odwołania do elementu przechowywanego w mapie.
`reverse_iterator`	Element typedef dla iteratora dwukierunkowego, który może odczytać lub zmodyfikować element w odwróconej mapie.
`size_type`	Całkowitoliczbowy element typedef bez znaku określający liczbę elementów w mapie.
`value_type`	Element typedef dla typu obiektu przechowywanego jako element w mapie.

Funkcje składowe

Funkcja składowa	opis
`at`	Znajduje element o określonej wartości klucza.
`begin`	Zwraca iterator wskazujący pierwszy element w elemecie `map`.
`cbegin`	Zwraca iterator const, który wskazuje na pierwszy element w elemecie `map`.
`cend`	Zwraca wartość const iteratora poza końcem.
`clear`	Usuwa wszystkie elementy elementu `map`.
`contains`^C++20	Sprawdź, czy w elemecie znajduje się element z określonym kluczem `map`.
`count`	Zwraca liczbę elementów w mapie, których klucz pasuje do klucza określonego w parametrze.
`crbegin`	Zwraca iterator const, który wskazuje pierwszy element w odwróconym elemecie `map`.
`crend`	Zwraca iterator const, który wskazuje lokalizację po ostatnim elemercie w odwróconym elemecie `map`.
`emplace`	Wstawia element skonstruowany w miejscu do elementu `map`.
`emplace_hint`	Wstawia element skonstruowany w miejscu do `map`elementu z wskazówką umieszczania.
`empty`	Zwraca wartość `true` , jeśli wartość jest pusta `map` .
`end`	Zwraca iterator poza końcem.
`equal_range`	Zwraca parę iteratorów. Pierwszy iterator w parze wskazuje pierwszy element w obiekcie `map` z kluczem większym niż określony klucz. Drugi iterator w parze wskazuje pierwszy element w `map` obiekcie z kluczem równym lub większym niż klucz.
`erase`	Usuwa element lub zakres elementów w mapie z określonych pozycji.
`find`	Zwraca iterator wskazujący lokalizację elementu w obiekcie `map` , który ma klucz równy określonemu kluczowi.
`get_allocator`	Zwraca kopię `allocator` obiektu, który jest używany do konstruowania obiektu `map`.
`insert`	Wstawia element lub zakres elementów do `map` obiektu w określonej pozycji.
`key_comp`	Zwraca kopię obiektu porównania używanego do zamawiania kluczy w obiekcie `map`.
`lower_bound`	Zwraca iterator do pierwszego elementu w obiekcie `map` , który ma wartość klucza równą lub większą niż określony klucz.
`max_size`	Zwraca maksymalną długość obiektu `map`.
`rbegin`	Zwraca iterator wskazujący pierwszy element w odwróconym `map`obiekcie .
`rend`	Zwraca iterator, który wskazuje lokalizację po ostatnim elemenie w odwróconym elemecie `map`.
`size`	Zwraca liczbę elementów w elem.`map`
`swap`	Zamienia elementy z dwóch map.
`upper_bound`	Zwraca iterator do pierwszego elementu w obiekcie `map` , który ma wartość klucza większą niż określony klucz.
`value_comp`	Pobiera kopię obiektu porównania, który jest używany do porządkowenia wartości elementów w obiekcie `map`.

Operatory

Nazwa/nazwisko	opis
`operator[]`	Wstawia element do mapy z określoną wartością klucza.
`operator=`	Zastępuje elementy mapy kopią innej mapy.

`allocator_type`

Typ reprezentujący klasę alokatora dla obiektu mapy.

typedef Allocator allocator_type;

Przykład

Zobacz przykład, aby zapoznać get_allocator się z przykładem, który używa elementu allocator_type.

`at`

Wyszukuje element z określoną wartością klucza.

Type& at(const Key& key);

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

Parametry

key
Wartość klucza do znalezienia.

Wartość zwracana

Odwołanie do wartości danych znalezionego elementu.

Uwagi

Jeśli wartość klucza argumentu nie zostanie znaleziona, funkcja zgłasza obiekt klasy out_of_range Class.

Przykład

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

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

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

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

    return (0);
    }

`begin`

Zwraca iterator odnoszący się do pierwszego elementu w elemecie map.

const_iterator begin() const;

iterator begin();

Wartość zwracana

Iterator dwukierunkowy odnoszący się do pierwszego elementu w map lokalizacji lub, który zakończył się powodzeniem pustej mapy.

Przykład

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

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

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

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

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

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

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

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

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

`cbegin`

Zwraca iterator, który adresuje lokalizację const tuż poza ostatnim elementem w zakresie.

const_iterator cbegin() const;

Wartość zwracana

const Iterator dwukierunkowy odnoszący się do pierwszego elementu w zakresie lub lokalizacji tuż poza końcem pustego zakresu (dla pustego zakresu, cbegin() == cend()).

Uwagi

Przy zwracanej wartości cbeginelementu nie można modyfikować elementów w zakresie.

Możesz użyć tej funkcji składowej zamiast funkcji składowej begin() , aby zagwarantować, że zwracana wartość to const_iterator. Zazwyczaj jest używany w połączeniu ze auto słowem kluczowym potrącenia typu, jak pokazano w poniższym przykładzie. W tym przykładzie rozważmy Container , aby być kontenerem modyfikowalnym (innym niż const) jakiegokolwiek rodzaju, który obsługuje begin() i cbegin().

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

// i2 is Container<T>::const_iterator

`cend`

Zwraca iterator, który adresuje lokalizację const tuż poza ostatnim elementem w zakresie.

const_iterator cend() const;

Wartość zwracana

const Iterator dostępu dwukierunkowego, który wskazuje tuż poza końcem zakresu.

Uwagi

cend służy do testowania, czy iterator przeszedł koniec jego zakresu.

Możesz użyć tej funkcji składowej zamiast funkcji składowej end() , aby zagwarantować, że zwracana wartość to const_iterator. Zazwyczaj jest używany w połączeniu ze auto słowem kluczowym potrącenia typu, jak pokazano w poniższym przykładzie. W tym przykładzie rozważmy Container , aby być kontenerem modyfikowalnym (innym niż const) jakiegokolwiek rodzaju, który obsługuje end() i cend().

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

// i2 is Container<T>::const_iterator

Wartość zwracana przez cend nie powinna być wyłuszczone.

`clear`

Usuwa wszystkie elementy mapy.

void clear();

Przykład

W poniższym przykładzie pokazano użycie funkcji składowej map::clear .

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

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

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

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

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

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

`const_iterator`

Typ, który udostępnia iterator dwukierunkowy, który może odczytać const element w obiekcie map.

typedef implementation-defined const_iterator;

Uwagi

Nie można użyć typu const_iterator do modyfikowania wartości elementu.

Zdefiniowane const_iterator przez mapowanie wskazuje elementy, które są obiektami value_type, czyli typu pair<constKey, Type>, którego pierwszy element członkowski jest kluczem do elementu i którego drugi element członkowski jest mapowanym datum trzymane przez element.

Aby wyłuszczyć const_iteratorcIter element w mapie, użyj -> operatora .

Aby uzyskać dostęp do wartości klucza dla elementu, użyj -cIter>first, który jest odpowiednikiem (* ). cIter first.

Aby uzyskać dostęp do wartości zamapowanego datum dla elementu, użyj -cIter>second, który jest odpowiednikiem (* cIter). second.

Przykład

Zobacz przykład, aby zapoznać begin się z przykładem, który używa elementu const_iterator.

`const_pointer`

Typ, który dostarcza wskaźnik do const elementu na mapie.

typedef typename allocator_type::const_pointer const_pointer;

Uwagi

Nie można użyć typu const_pointer do modyfikowania wartości elementu.

W większości przypadków iterator element powinien być używany do uzyskiwania dostępu do elementów w obiekcie mapy.

`const_reference`

Typ, który zawiera odwołanie do elementu przechowywanego const na mapie na potrzeby odczytywania i wykonywania const operacji.

typedef typename allocator_type::const_reference const_reference;

Przykład

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

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

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

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

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

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

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

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

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

`const_reverse_iterator`

Typ, który udostępnia iterator dwukierunkowy, który może odczytywać dowolny const element w obiekcie map.

typedef std::reverse_iterator<const_iterator> const_reverse_iterator;

Uwagi

Typ const_reverse_iterator nie może modyfikować wartości elementu i jest używany do iteracji po mapie w odwrotnej kolejności.

Zdefiniowane const_reverse_iterator przez mapowanie wskazuje elementy, które są obiektami value_type, czyli typu pair<const Key, Type>, którego pierwszy element członkowski jest kluczem do elementu i którego drugi element członkowski jest mapowanym datum trzymane przez element.

Aby wyłuszczyć const_reverse_iterator crIter element w mapie, użyj -> operatora .

Aby uzyskać dostęp do wartości klucza dla elementu, użyj -crIter>first, który jest odpowiednikiem (* crIter)..first

Aby uzyskać dostęp do wartości mapowanego datum dla elementu, użyj -crIter>second, który jest odpowiednikiem (* crIter)..first

Przykład

Zobacz przykład, aby zapoznać się z przykładem rend sposobu deklarowania i używania elementu const_reverse_iterator.

`count`

Zwraca liczbę elementów na mapie, których klucz pasuje do klucza określonego parametrem.

size_type count(const Key& key) const;

Parametry

key
Wartość klucza elementów do dopasowania z mapy.

Wartość zwracana

1, jeśli mapa zawiera element, którego klucz sortowania pasuje do klucza parametru; 0, jeśli mapa nie zawiera elementu z pasującym kluczem.

Uwagi

Funkcja składowa zwraca liczbę elementów x w zakresie

[ lower_bound(klucz), upper_bound(klucz) )

czyli 0 lub 1 w przypadku mapy, która jest unikatowym kontenerem asocjacyjnym.

Przykład

W poniższym przykładzie pokazano użycie funkcji składowej map::count .

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

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

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

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

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

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

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

`contains`

Sprawdza, czy w elemecie znajduje się element z określonym kluczem map.

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

Parametry

K
Typ klucza.

key
Wartość klucza elementu do wyszukania.

Wartość zwracana

true jeśli element zostanie znaleziony w kontenerze; false Inaczej.

Uwagi

contains() jest nowy w języku C++20. Aby go użyć, określ lub nowszą /std:c++20 opcję kompilatora.

template<class K> bool contains(const K& key) const Uczestniczy tylko w rozwiązywaniu przeciążeń, jeśli key_compare jest przezroczysty. Aby uzyskać więcej informacji, zobacz Heterogeniczne wyszukiwanie w kontenerach asocjacyjnych.

Przykład

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

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

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

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

    return 0;
}

true
false
true

`crbegin`

Zwraca iterator const odnoszący się do pierwszego elementu w odwróconej mapie.

const_reverse_iterator crbegin() const;

Wartość zwracana

Odwrotny iterator dwukierunkowy odnoszący się do pierwszego elementu w odwróconym map lub odnoszącym się do tego, co było ostatnim elementem w niewróceniu map.

Uwagi

crbegin jest używany z odwróconym map elementem, tak jak begin jest używany z elementem map.

Przy użyciu wartości zwracanej crbeginmap obiektu nie można zmodyfikować

crbegin może służyć do iterowania przez map tyły.

Przykład

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

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

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

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

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

The first element of the reversed map m1 is 3.

`crend`

Zwraca iterator const, który adresuje lokalizację, która zakończyła się powodzeniem ostatniego elementu w odwróconej mapie.

const_reverse_iterator crend() const;

Wartość zwracana

Odwrotny iterator dwukierunkowy, który adresuje lokalizację, która zakończyła się powodzeniem ostatniego elementu w odwróconym map elemecie (lokalizacja, która poprzedzała pierwszy element w niereversedowanym map).

Uwagi

crend jest używany z odwróconą mapą tak samo jak end w przypadku map.

Przy użyciu wartości zwracanej crendmap obiektu nie można modyfikować.

crend można użyć do sprawdzenia, czy iterator odwrotny osiągnął koniec jego map.

Wartość zwracana przez crend nie powinna być wyłuszczone.

Przykład

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

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

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

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

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

The last element of the reversed map m1 is 1.

`difference_type`

Typ liczby całkowitej ze znakiem, który może służyć do reprezentowania liczby elementów mapy w zakresie między elementami wskazywanym przez iteratory.

typedef allocator_type::difference_type difference_type;

Uwagi

Jest difference_type to typ zwracany podczas odejmowania lub przyrostowania przez iteratory kontenera. Element difference_type jest zwykle używany do reprezentowania liczby elementów w zakresie [pierwszy, ostatni) między iteratorami first i last, zawiera element wskazywany przez first i zakres elementów do, ale nie uwzględnia elementu wskazywanego przez last.

Mimo difference_type że jest dostępna dla wszystkich iteratorów, które spełniają wymagania iteratora wejściowego, który obejmuje klasę iteratorów dwukierunkowych obsługiwanych przez kontenery odwracalne, takie jak zestaw, odejmowanie między iteratorami jest obsługiwane tylko przez iteratory dostępu losowego udostępniane przez kontener dostępu losowego, takiego jak wektor.

Przykład

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

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

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

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

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

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

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

`emplace`

Wstawia element skonstruowany na miejscu (nie są wykonywane żadne operacje kopiowania lub przenoszenia) do mapy.

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

Parametry

args
Argumenty przekazane w celu skonstruowania elementu do wstawienia do mapy, chyba że zawiera już element, którego wartość jest równoważnie uporządkowana.

Wartość zwracana

Element pair , którego bool składnik ma true wartość , jeśli utworzono wstawienie, a false mapa zawierała już element równoważnej wartości w kolejności. Składnik iteratora pary return-value wskazuje nowo wstawiony element, jeśli bool składnik ma wartość true, lub do istniejącego elementu, jeśli bool składnik ma wartość false.

Aby uzyskać dostęp do składnika iteratora obiektu pairpr, użyj polecenia pr.first; aby go wyłuszczyć, użyj polecenia *pr.first. Aby uzyskać dostęp do bool składnika, użyj polecenia pr.second. Przykładowy kod można znaleźć w dalszej części tego artykułu.

Uwagi

Ta funkcja nie unieważnia iteratorów ani odwołań.

W przypadku zgłoszenia wyjątku stan kontenera nie jest modyfikowany podczas zastępowania.

Element value_type jest parą, dzięki czemu wartość elementu będzie uporządkowaną parą z pierwszym składnikiem równym wartości klucza i drugiemu składnikowi równemu wartości danych elementu.

Przykład

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

using namespace std;

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

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

    cout << endl;
}

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

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

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

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

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

`emplace_hint`

Wstawia element skonstruowany na miejscu (nie są wykonywane żadne operacje kopiowania lub przenoszenia) z wskazówką umieszczania.

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

Parametry

args
Argumenty przekazywane do konstruowania elementu do wstawiania do mapy, chyba że mapa zawiera już ten element lub, ogólnie rzecz biorąc, chyba że zawiera już element, którego klucz jest równoważny.

where
Miejsce, w którym należy rozpocząć wyszukiwanie poprawnego punktu wstawiania. (Jeśli ten punkt bezpośrednio poprzedza miejsce, wstawienie może wystąpić w amortyzowanym stałym czasie zamiast czasu logarytmicznych).

Wartość zwracana

Iterator nowo wstawiony element.

Jeśli wstawianie nie powiodło się, ponieważ element już istnieje, zwraca iterator do istniejącego elementu z jego kluczem.

Uwagi

Ta funkcja nie unieważnia iteratorów ani odwołań.

W przypadku zgłoszenia wyjątku stan kontenera nie jest modyfikowany podczas zastępowania.

Przykład

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

using namespace std;

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

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

    cout << endl;
}

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

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

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

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

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

`empty`

Sprawdza, czy mapa jest pusta.

bool empty() const;

Wartość zwracana

true jeśli mapa jest pusta; false jeśli mapa nie jest żadna.

Przykład

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

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

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

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

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

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

`end`

Zwraca iterator poza końcem.

const_iterator end() const;

iterator end();

Wartość zwracana

Iterator przeszłości. Jeśli mapa jest pusta, to map::end() == map::begin().

Uwagi

end służy do testowania, czy iterator przeszedł koniec mapy.

Wartość zwracana przez end nie powinna być wyłuszczone.

Aby zapoznać się z przykładem kodu, zobacz map::find.

`equal_range`

Zwraca parę iteratorów reprezentujących lower_bound klucz i upper_bound klucz.

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

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

Parametry

key
Wartość klucza argumentu do porównania z kluczem sortowania elementu z przeszukiwanej mapy.

Wartość zwracana

Aby uzyskać dostęp do pierwszego iteratora pary pr zwróconej przez funkcję składową, użyj polecenia pr. najpierw i aby wyłusić iterator dolnej granicy, użyj *( pr. pierwszy). Aby uzyskać dostęp do drugiego iteratora pary pr zwróconej przez funkcję składową, użyj polecenia pr. drugi i aby wyłuskać iterator górnej granicy, użyj *( pr. sekunda).

Przykład

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

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

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

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

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

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

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

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

   p2 = m1.equal_range( 4 );

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

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

`erase`

Usuwa element lub zakres elementów na mapie z określonych pozycji lub usuwa elementy zgodne z określonym kluczem.

iterator erase(
    const_iterator Where);

iterator erase(
    const_iterator First,
    const_iterator Last);

size_type erase(
    const key_type& Key);

Parametry

Where
Położenie elementu do usunięcia.

First
Pozycja pierwszego elementu do usunięcia.

Last
Pozycja tuż poza ostatnim elementem, który ma zostać usunięty.

Key
Wartość klucza elementów do usunięcia.

Wartość zwracana

W przypadku pierwszych dwóch funkcji składowych iterator dwukierunkowy, który wyznacza pierwszy element pozostały poza usuniętymi elementami lub elementem, który jest końcem mapy, jeśli taki element nie istnieje.

W przypadku trzeciej funkcji składowej zwraca liczbę elementów, które zostały usunięte z mapy.

Przykład

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

using namespace std;

using mymap = map<int, string>;

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

int main()
{
    mymap m1;

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

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

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

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

    mymap m3;

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

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

`find`

Zwraca iterator odwołujący się do lokalizacji elementu na mapie, który ma klucz odpowiadający określonemu kluczowi.

iterator find(const Key& key);

const_iterator find(const Key& key) const;

Parametry

key
Wartość klucza, która ma być zgodna z kluczem sortowania elementu z przeszukiwanej mapy.

Wartość zwracana

Iterator odwołujący się do lokalizacji elementu z określonym kluczem lub lokalizacji, która zakończyła się powodzeniem ostatniego elementu w elemecie map (map::end()), jeśli nie zostanie znalezione dopasowanie klucza.

Uwagi

Funkcja składowa zwraca iterator, który odwołuje się do elementu w kluczu map sortowania, którego klucz sortowania jest odpowiednikiem klucza argumentu w predykacie binarnym, który wywołuje kolejność na podstawie relacji mniejszej niż porównywalność.

Jeśli wartość zwracana find elementu jest przypisana do const_iteratorobiektu , nie można zmodyfikować obiektu mapy. Jeśli wartość zwracana find elementu jest przypisana do iteratorobiektu , można zmodyfikować obiekt mapy

Przykład

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

using namespace std;

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

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

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

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

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

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

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

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

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

`get_allocator`

Zwraca kopię obiektu alokatora używanego do konstruowania mapy.

allocator_type get_allocator() const;

Wartość zwracana

Alokator używany przez mapę.

Uwagi

Alokatory dla klasy mapy określają sposób zarządzania magazynem przez klasę. Domyślne alokatory dostarczane z klasami kontenerów biblioteki standardowej języka C++ są wystarczające dla większości potrzeb programistycznych. Pisanie i używanie własnej klasy alokatora jest zaawansowanym tematem języka C++.

Przykład

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

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

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

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

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

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

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

   m4_Alloc = m4.get_allocator( );

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

`insert`

Wstawia element lub zakres elementów do mapy.

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

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

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

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

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

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

Parametry

Val
Wartość elementu do wstawienia do mapy, chyba że zawiera już element, którego klucz jest odpowiednio uporządkowany.

Where
Miejsce, w którym należy rozpocząć wyszukiwanie poprawnego punktu wstawiania. (Jeśli ten punkt bezpośrednio poprzedza Where, wstawienie może wystąpić w amortyzowanym czasie stałym zamiast czasu logarytmicznych).

ValTy
Parametr szablonu określający typ argumentu, którego mapa może użyć do skonstruowania elementu value_type, i idealnego do przodu Val jako argumentu.

First
Położenie pierwszego elementu do skopiowania.

Last
Pozycja tuż poza ostatnim elementem do skopiowania.

InputIterator
Argument funkcji szablonu spełniający wymagania iteratora wejściowego wskazujący elementy typu, które mogą służyć do konstruowania value_type obiektów.

IList
Element initializer_list , z którego mają być skopiowane elementy.

Wartość zwracana

Funkcje składowe z jednym elementem, (1) i (2), zwracają pair wartość, której bool składnik ma wartość true, jeśli wstawienie zostało wykonane, i fałsz, jeśli mapa zawierała już element, którego klucz miał równoważną wartość w kolejności. Składnik iteratora pary return-value wskazuje nowo wstawiony element, jeśli bool składnik ma wartość true, lub do istniejącego elementu, jeśli bool składnik ma wartość false.

Funkcje składowe single-element-with-hint, (3) i (4), zwracają iterator wskazujący położenie, w którym nowy element został wstawiony do mapy lub, jeśli element z równoważnym kluczem już istnieje, do istniejącego elementu.

Uwagi

Ta funkcja nie unieważnia iteratorów, wskaźników ani odwołań.

Podczas wstawiania tylko jednego elementu, jeśli zgłaszany jest wyjątek, stan kontenera nie jest modyfikowany. Podczas wstawiania wielu elementów, jeśli zostanie zgłoszony wyjątek, kontener pozostanie w nieokreślonym, ale prawidłowym stanie.

Aby uzyskać dostęp do składnika pairpr iteratora zwracanego przez funkcje składowe z jednym elementem, użyj polecenia pr.first; aby wyłusić iterator w zwróconej parze, użyj polecenia *pr.first, dając element. Aby uzyskać dostęp do bool składnika, użyj polecenia pr.second. Przykładowy kod można znaleźć w dalszej części tego artykułu.

Kontener value_type to definicja typu, która należy do kontenera, a dla mapowania map<K, V>::value_type to pair<const K, V>. Wartość elementu jest uporządkowaną parą, w której pierwszy składnik jest równy wartości klucza, a drugi składnik jest równy wartości danych elementu.

Funkcja składowa zakresu (5) wstawia sekwencję wartości elementów do mapy odpowiadającej każdemu elementowi adresowanemu przez iterator w zakresie [First, Last); w związku z tym Last nie zostanie wstawiona. Funkcja end() składowa kontenera odwołuje się do pozycji tuż po ostatnim elemencie w kontenerze — na przykład instrukcja m.insert(v.begin(), v.end()); próbuje wstawić wszystkie elementy v do melementu . Wstawiane są tylko elementy, które mają unikatowe wartości w zakresie; duplikaty są ignorowane. Aby sprawdzić, które elementy są odrzucane, należy użyć wersji pojedynczego elementu programu insert.

Funkcja składowa listy inicjatora (6) używa elementu initializer_list do kopiowania elementów do mapy.

W przypadku wstawiania elementu skonstruowanego na miejscu — czyli nie są wykonywane żadne operacje kopiowania lub przenoszenia — zobacz map::emplace i map::emplace_hint.

Przykład

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

using namespace std;

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

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

    cout << endl;
}

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

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

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

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

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

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

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

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

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

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

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

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

`iterator`

Typ, który udostępnia iterator dwukierunkowy, który może odczytywać lub modyfikować dowolny element na mapie.

typedef implementation-defined iterator;

Uwagi

Iterator zdefiniowany przez mapę wskazuje elementy, które są obiektami value_type, czyli typu pair<const Key, Type>, którego pierwszy element członkowski jest kluczem do elementu i którego drugi element członkowski jest mapowanym datą przechowywaną przez element.

Aby wyłudić iterator iteratora wskazujący element na mapie, użyj -> operatora .

Aby uzyskać dostęp do wartości klucza dla elementu, użyj elementu Iter->first, który jest odpowiednikiem (*Iter).first. Aby uzyskać dostęp do wartości mapowanej datum dla elementu, użyj elementu Iter->second, który jest odpowiednikiem (*Iter).second.

Przykład

Zobacz przykład, aby zapoznać begin się z przykładem sposobu deklarowania i używania elementu iterator.

`key_comp`

Pobiera kopię obiektu porównania używanego do zamawiania kluczy na mapie.

key_compare key_comp() const;

Wartość zwracana

Zwraca obiekt funkcji używany przez mapę w celu uporządkowania jego elementów.

Uwagi

Przechowywany obiekt definiuje funkcję składową

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

funkcja zwraca wartość true , jeśli left poprzedza wartość i nie jest równa right w kolejności sortowania.

Przykład

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

int main( )
{
   using namespace std;

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

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

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

`key_compare`

Typ, który udostępnia obiekt funkcji, który może porównać dwa klucze sortowania, aby określić względną kolejność dwóch elementów w obiekcie map.

typedef Traits key_compare;

Uwagi

key_compare jest synonimem parametru Traitsszablonu .

Aby uzyskać więcej informacji na temat Traitsprogramu , zobacz map temat Klasa .

Przykład

Zobacz przykład, aby zapoznać key_comp się z przykładem sposobu deklarowania i używania elementu key_compare.

`key_type`

Typ opisujący klucz sortowania przechowywany w każdym elemercie mapy.

typedef Key key_type;

Uwagi

key_type jest synonimem parametru Keyszablonu .

Aby uzyskać więcej informacji na temat Key, zobacz sekcję map Uwagi w temacie Klasa.

Przykład

Zobacz przykład, aby zapoznać value_type się z przykładem sposobu deklarowania i używania elementu key_type.

`lower_bound`

Zwraca iterator do pierwszego elementu na mapie z wartością klucza, która jest równa lub większa od określonego klucza.

iterator lower_bound(const Key& key);

const_iterator lower_bound(const Key& key) const;

Parametry

key
Wartość klucza argumentu do porównania z kluczem sortowania elementu z przeszukiwanej mapy.

Wartość zwracana

Element iterator lub const_iterator adresujący lokalizację elementu na mapie z kluczem równym lub większym niż klucz argumentu albo adresuje lokalizację, która zakończyła się powodzeniem ostatniego elementu w obiekcie , map jeśli nie zostanie znalezione dopasowanie klucza.

Jeśli wartość zwracana lower_bound elementu jest przypisana do const_iteratorobiektu , nie można zmodyfikować obiektu mapy. Jeśli zwracana wartość lower_bound elementu jest przypisana do iteratorobiektu , można zmodyfikować obiekt mapy.

Przykład

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

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

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

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

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

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

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

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

`map`

Tworzy mapę, która jest pusta lub jest kopią wszystkich lub części innej mapy.

map();

explicit map(
    const Traits& Comp);

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

map(
    const map& Right);

map(
    map&& Right);

map(
    initializer_list<value_type> IList);

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

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

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

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

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

Parametry

Al
Klasa alokatora magazynu, która ma być używana dla tego obiektu mapy, który domyślnie ma wartość Allocator.

Comp
Funkcja porównania typu const Traits używana do porządkowenia elementów w mapobiekcie , która jest domyślnie ustawiona na hash_compare.

Right
Mapa, której skonstruowany zestaw ma być kopią.

First
Położenie pierwszego elementu w zakresie elementów do skopiowania.

Last
Położenie pierwszego elementu poza zakresem elementów do skopiowania.

IList
Initializer_list, z którego mają zostać skopiowane elementy.

Uwagi

Wszystkie konstruktory przechowują typ obiektu alokatora, który zarządza magazynem pamięci dla mapy i który może zostać później zwrócony przez wywołanie metody get_allocator. Parametr alokatora jest często pomijany w deklaracjach klas i makrach przetwarzania wstępnego używanych do zastępowania alternatywnych alokatorów.

Wszystkie konstruktory inicjują mapę.

Wszystkie konstruktory przechowują obiekt funkcji typu Traits, który jest używany do ustanowienia kolejności między kluczami mapy i które można później zwrócić przez wywołanie metody key_comp.

Pierwsze trzy konstruktory określają pustą mapę początkową, drugą określającą typ funkcji porównania (Comp), która ma być używana w ustanawianiu kolejności elementów, a trzecia jawnie określająca typ alokatora (Al) do użycia. Słowo explicit kluczowe pomija niektóre rodzaje automatycznej konwersji typów.

Czwarty konstruktor określa kopię mapy Right.

Piąty konstruktor określa kopię mapy, przenosząc Rightelement .

Konstruktory 6, 7 i 8 używają initializer_list elementu , z którego będą kopiować elementy członkowskie.

Następne trzy konstruktory kopiują zakres [First, Last) mapy z rosnącą jawnością w określaniu typu funkcji porównania klasy Traits i alokatora.

Przykład

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

`mapped_type`

Typ reprezentujący dane przechowywane na mapie.

typedef Type mapped_type;

Uwagi

Typ mapped_type jest synonimem parametru szablonu typu klasy.

Aby uzyskać więcej informacji na temat Typeprogramu , zobacz map temat Klasa .

Przykład

Zobacz przykład, aby zapoznać value_type się z przykładem sposobu deklarowania i używania elementu mapped_type.

`max_size`

Zwraca maksymalną długość mapy.

size_type max_size() const;

Wartość zwracana

Maksymalna możliwa długość mapy.

Przykład

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

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

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

`operator[]`

Wstawia element do mapy z określoną wartością klucza.

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

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

Parametry

key
Wartość klucza elementu, który ma być wstawiony.

Wartość zwracana

Odwołanie do wartości danych wstawionego elementu.

Uwagi

Jeśli wartość klucza argumentu nie zostanie znaleziona, zostanie wstawiona wraz z wartością domyślną typu danych.

operator[] może służyć do wstawiania elementów do mapy m przy użyciu m[key] = DataValue; metody where DataValue jest wartością mapped_type elementu z wartością keyklucza .

W przypadku używania operator[] polecenia do wstawiania elementów zwrócone odwołanie nie wskazuje, czy wstawienie zmienia wstępnie istniejący element, czy tworzy nowy. Funkcje find składowe i insert mogą służyć do określenia, czy element z określonym kluczem jest już obecny przed wstawieniem.

Przykład

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

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

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

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

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

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

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

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

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

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

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

    return (0);
}

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

`operator=`

Zastępuje elementy mapy kopią innej mapy.

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

Parametry

right
Element map kopiowany do pliku map.

Uwagi

Po wymazaniu wszystkich istniejących elementów w obiekcie mapoperator= , kopiuje lub przenosi zawartość right do mapy.

Przykład

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

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

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

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

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

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

`pointer`

Typ, który dostarcza wskaźnik do elementu na mapie.

typedef typename allocator_type::pointer pointer;

Uwagi

pointer Typ może służyć do modyfikowania wartości elementu.

W większości przypadków iterator element powinien być używany do uzyskiwania dostępu do elementów w obiekcie mapy.

rbegin

Zwraca iterator odnoszący się do pierwszego elementu w odwróconej mapie.

const_reverse_iterator rbegin() const;

reverse_iterator rbegin();

Wartość zwracana

Odwrotny iterator dwukierunkowy odnoszący się do pierwszego elementu w odwróconej mapie lub adresowania, co było ostatnim elementem w niereversedowanej mapie.

Uwagi

rbegin jest używany z odwróconą mapą tak samo jak begin używana z mapą.

Jeśli wartość zwracana rbegin elementu jest przypisana do const_reverse_iteratorobiektu , nie można zmodyfikować obiektu mapy. Jeśli zwracana wartość rbegin elementu jest przypisana do reverse_iteratorobiektu , można zmodyfikować obiekt mapy.

rbegin można użyć do iterowania mapy do tyłu.

Przykład

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

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

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

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

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

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

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

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

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

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

`reference`

Typ, który zawiera odwołanie do elementu przechowywanego na mapie.

typedef typename allocator_type::reference reference;

Przykład

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

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

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

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

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

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

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

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

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

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

`rend`

Zwraca iterator, który odnosi się do lokalizacji, która zakończyła się powodzeniem ostatniego elementu w odwróconej mapie.

const_reverse_iterator rend() const;

reverse_iterator rend();

Wartość zwracana

Odwrotny iterator dwukierunkowy, który adresuje lokalizację, która zakończyła się powodzeniem ostatniego elementu w odwróconej mapie (lokalizacja, która poprzedzała pierwszy element w niewróconej mapie).

Uwagi

rend jest używany z odwróconą mapą tak samo jak end używana z mapą.

Jeśli wartość zwracana rend elementu jest przypisana do const_reverse_iteratorobiektu , nie można zmodyfikować obiektu mapy. Jeśli zwracana wartość rend elementu jest przypisana do reverse_iteratorobiektu , można zmodyfikować obiekt mapy.

rend można użyć do sprawdzenia, czy iterator odwrotny osiągnął koniec mapy.

Wartość zwracana przez rend nie powinna być wyłuszczone.

Przykład

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

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

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

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

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

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

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

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

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

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

`reverse_iterator`

Typ, który udostępnia iterator dwukierunkowy, który może odczytywać lub modyfikować element w odwróconej mapie.

typedef std::reverse_iterator<iterator> reverse_iterator;

Uwagi

Typ reverse_iterator nie może modyfikować wartości elementu i jest używany do iteracji po mapie w odwrotnej kolejności.

Zdefiniowane reverse_iterator przez mapowanie wskazuje elementy, które są obiektami value_type, czyli typu pair<const Key, Type>, którego pierwszy element członkowski jest kluczem do elementu i którego drugi element członkowski jest mapowanym datum trzymane przez element.

Aby wyłusić reverse_iteratorrIter wskazujący element na mapie, użyj -> operatora .

Aby uzyskać dostęp do wartości klucza dla elementu, użyj -rIter>first, który jest odpowiednikiem (* ). rIter pierwszy. Aby uzyskać dostęp do wartości mapowanego elementu datum, użyj rIter ->second, który jest odpowiednikiem (* rIter). pierwszy.

Przykład

Zobacz przykład, aby zapoznać rbegin się z przykładem sposobu deklarowania i używania elementu reverse_iterator.

`size`

Zwraca liczbę elementów w elem.map

size_type size() const;

Wartość zwracana

Bieżąca długość mapy.

Przykład

W poniższym przykładzie pokazano użycie funkcji składowej map::size .

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

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

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

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

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

`size_type`

Niepodpisany typ liczb całkowitych, który może reprezentować liczbę elementów na mapie.

typedef typename allocator_type::size_type size_type;

Przykład

Zobacz przykład, aby zapoznać się z przykładem size sposobu deklarowania i używania elementu size_type.

swap

Zamienia elementy z dwóch map.

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

Parametry

right
Mapa argumentów dostarczająca elementy do zamiany z mapą docelową.

Uwagi

Funkcja składowa unieważnia żadne odwołania, wskaźniki lub iteratory, które wyznaczają elementy na dwóch mapach, których elementy są wymieniane.

Przykład

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

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

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

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

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

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

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

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

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

`upper_bound`

Zwraca iterator do pierwszego elementu na mapie, który z kluczem o wartości większej niż określony klucz.

iterator upper_bound(const Key& key);

const_iterator upper_bound(const Key& key) const;

Parametry

key
Wartość klucza argumentu do porównania z wartością klucza sortowania elementu z przeszukiwanej mapy.

Wartość zwracana

Element iterator lub const_iterator adresujący lokalizację elementu na mapie z kluczem większym niż klucz argumentu lub adresujący lokalizację, która zakończyła się powodzeniem ostatniego elementu w obiekcie , map jeśli nie zostanie znalezione dopasowanie klucza.

Jeśli wartość zwracana jest przypisana do const_iteratorobiektu , nie można zmodyfikować obiektu mapy. Jeśli wartość zwracana jest przypisana do iteratorobiektu , można zmodyfikować obiekt mapy.

Przykład

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

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

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

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

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

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

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

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

`value_comp`

Funkcja składowa zwraca obiekt funkcji, który określa kolejność elementów na mapie, porównując ich wartości klucza.

value_compare value_comp() const;

Wartość zwracana

Zwraca obiekt funkcji porównania używany przez mapę w celu uporządkowania jego elementów.

Uwagi

W przypadku mapy m, jeśli dwa elementy e1(k1, d1) i e2(k2, d2) są obiektami typu value_type, gdzie k1 i k1 są ich kluczami typu key_type i d1 i d2 są ich danymi typu mapped_type, to m.value_comp(e1, e2) jest równoważne m.key_comp(k1, k2). Przechowywany obiekt definiuje funkcję składową

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

wartość , która zwraca true wartość klucza poprzedniego left i nie jest równa wartości right klucza w kolejności sortowania.

Przykład

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

int main( )
{
   using namespace std;

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

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

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

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

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

`value_type`

Typ obiektu przechowywanego jako element na mapie.

typedef pair<const Key, Type> value_type;

Przykład

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

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

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

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

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

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

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

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

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

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

Zobacz też

Kontenery
Bezpieczeństwo wątku w standardowej bibliotece C++
Dokumentacja standardowej biblioteki C++

Share via

map Klasa

Składnia

Parametry

Uwagi

Członkowie

Konstruktory

Typedefs

Funkcje składowe

Operatory

allocator_type

Przykład

at

Parametry

Wartość zwracana

Uwagi

Przykład

begin

Wartość zwracana

Przykład

cbegin

Wartość zwracana

Uwagi

cend

Wartość zwracana

Uwagi

clear

Przykład

const_iterator

Uwagi

Przykład

const_pointer

Uwagi

const_reference

Przykład

const_reverse_iterator

Uwagi

Przykład

count

Parametry

Wartość zwracana

Uwagi

Przykład

contains

Parametry

Wartość zwracana

Uwagi

Przykład

crbegin

Wartość zwracana

Uwagi

Przykład

crend

Wartość zwracana

Uwagi

Przykład

difference_type

Uwagi

Przykład

emplace

Parametry

Wartość zwracana

Uwagi

Przykład

emplace_hint

Parametry

Wartość zwracana

Uwagi

Przykład

empty

Wartość zwracana

Przykład

end

Wartość zwracana

Uwagi

equal_range

Parametry

Wartość zwracana

Przykład

erase

`map` Klasa

`allocator_type`

`at`

`begin`

`cbegin`

`cend`

`clear`

`const_iterator`

`const_pointer`

`const_reference`

`const_reverse_iterator`

`count`

`contains`

`crbegin`

`crend`

`difference_type`

`emplace`

`emplace_hint`

`empty`

`end`

`equal_range`

`erase`

`find`

`get_allocator`

`insert`

`iterator`

`key_comp`

`key_compare`

`key_type`

`lower_bound`

`map`

`mapped_type`

`max_size`

`operator[]`

`operator=`

`pointer`

`reference`

`rend`

`reverse_iterator`

`size`