`map` Třída

Článek
10/12/2023

Používá se pro ukládání a načítání dat z kolekce, ve které je každý prvek pár, který má datovou hodnotu a klíč řazení. Hodnota klíče je jedinečná a je použita k automatickému seřazení dat.

Hodnotu prvku v objektu map lze změnit přímo. Hodnota klíče je konstanta a nedá se změnit. Namísto toho hodnoty klíčů přidružené ke starým prvkům musí být odstraněny a nové hodnoty klíče musí být vloženy pro nové prvky.

Syntaxe

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

Parametry

Key
Datový typ klíče, který má být uložen v souboru map.

Type
Datový typ prvku, který má být uložen v souboru map.

Traits
Typ, který poskytuje objekt funkce, který může porovnat dvě hodnoty prvků jako klíče řazení určit jejich relativní pořadí v map. Tento argument je nepovinný a binární predikát less<Key> je výchozí hodnota.

V jazyce C++14 můžete povolit heterogenní vyhledávání zadáním std::less<> predikátu, který neobsahuje parametry typu. Další informace najdete v tématu Heterogenní vyhledávání v asociativních kontejnerech .

Allocator
Typ představující uložený objekt alokátoru, který zapouzdřuje informace o přidělování a navrácení paměti zpět objektu map. Tento argument je nepovinný a výchozí hodnota je allocator<pair<const Key, Type> >.

Poznámky

Třída mapování standardní knihovny C++ je:

Kontejner s proměnnou velikostí, který efektivně načte hodnoty prvku na základě přidružených hodnot klíče.
Oboustranný, protože poskytuje obousměrné iterátory pro přístup k jeho prvkům.
Seřazená, protože její prvky jsou seřazeny podle hodnot klíče podle zadané funkce porovnání.
Jedinečný. protože každý z jeho prvků musí mít jedinečný klíč.
Kontejner asociativních párů, protože jeho prvky hodnoty dat se liší od hodnot klíčů.
Šablona třídy, protože funkce, které poskytuje, je obecná a nezávislá na prvku nebo typu klíče. Datové typy použité pro prvky a klíče jsou zadány jako parametry v šabloně třídy společně s funkcí porovnání a alokátorem.

Iterátor poskytovaný mapovou třídou je obousměrný iterátor, ale insert členské funkce třídy map mají verze, které berou jako parametry šablony slabší vstupní iterátor, jehož požadavky na funkčnost jsou menší než požadavky na funkce zaručené třídou obousměrných iterátorů. Různé koncepty iterátorů se týkají upřesnění jejich funkčnosti. Každý koncept iterátoru má vlastní sadu požadavků a algoritmy, které s ním pracují musí být omezeny těmito požadavky. Ke vstupnímu iterátoru lze přistoupit přes ukazatel pro odkazování na některý objekt a může být zvýšena na další iterátor v sekvenci.

Doporučujeme založit volbu typu kontejneru podle druhu vyhledávání a vkládání, který je požadován aplikací. Asociativní kontejnery jsou optimalizovány pro operace vyhledávání, vkládání a odstranění. Členské funkce, které tyto operace explicitně podporují, je dělají v nejhorším případě, který je úměrný logaritmus počtu prvků v kontejneru. Vkládání prvků nezruší platnost žádných iterátorů a odstranění prvků zruší platnost pouze těch iterátorů, které výslovně odkazovaly na odstraněné prvky.

Doporučujeme objekt map vytvořit jako asociativní kontejner volby, pokud jsou v aplikaci splněny podmínky, které přiřazují hodnoty klíčům. Model tohoto typu struktury je uspořádaný seznam jednoznačně se vyskytujících klíčových slov, které mají přidružené hodnoty řetězce poskytující definice. Pokud má slovo více než jednu správnou definici, takže klíč není jedinečný, pak by vícemap byl kontejner podle výběru. Pokud je uložen jen seznam slov, pak by třída set měla být vhodným kontejnerem. Pokud je povoleno více výskytů slova, měla by být použita třída multiset.

Mapa objedná prvky, které řídí voláním uloženého objektu funkce typu key_compare. Tento uložený objekt je porovnávací funkce, ke které se přistupuje voláním key_comp metody. Obecně platí, že se všechny dva dané prvky porovnávají a určují, jestli je jedna menší než druhá, nebo jestli jsou ekvivalentní. Při porovnání všech prvků je vytvořena seřazená sekvence neekvivalentních prvků.

Poznámka

Funkce porovnání je binární predikát, který indukuje přísné slabé seřazení ve standardním matematickém smyslu. Binární predikát f(x;y) je objekt funkce, který má dva argumentové objekty x a y a návratovou true hodnotu nebo false. Řazení stanovené pro množinu je striktní slabé řazení, pokud je binární predikát neflexivní, antisymetrické a tranzitivní, a pokud je ekvivalence tranzitivní, kde jsou dva objekty x a y definovány tak, aby byly ekvivalentní, pokud jsou f(x;y) a f(y;x) false. Pokud silnější podmínka rovnosti mezi klíči nahradí ekvivalenci, stane se pořadí celkovým (v tom smyslu, že všechny prvky jsou uspořádány ve vztahu k sobě navzájem) a odpovídající klíče budou od sebe nerozeznatelné.

V jazyce C++14 můžete povolit heterogenní vyhledávání zadáním std::less<> nebo std::greater<> predikátu, který neobsahuje parametry typu. Další informace najdete v tématu Heterogenní vyhledávání v asociativních kontejnerech .

Členové

Konstruktory

Jméno	popis
`map`	Vytvoří seznam určité velikosti nebo s prvky určité hodnoty nebo s určitými `allocator` nebo jako kopie některé jiné mapy.

Typedefs

Jméno	popis
`allocator_type`	Typedef pro `allocator` třídu pro objekt mapy.
`const_iterator`	Typedef pro obousměrný iterátor, který může číst `const` prvek v souboru `map`.
`const_pointer`	Typedef pro ukazatel na `const` prvek v mapě.
`const_reference`	Typedef pro odkaz na `const` prvek uložený v mapě pro čtení a provádění `const` operací.
`const_reverse_iterator`	Typ, který poskytuje obousměrný iterátor, který může číst libovolný `const` prvek v objektu `map`.
`difference_type`	Definice typu celého čísla se znaménkem pro počet prvků objektu map v rozsahu mezi prvky, na které odkazují iterátory.
`iterator`	Definice typu obousměrného iterátoru, který může číst nebo upravovat libovolný prvek v objektu map.
`key_compare`	Typedef pro objekt funkce, který může porovnat dva klíče řazení k určení relativního pořadí dvou prvků v objektu `map`.
`key_type`	Definice typu klíče řazení uloženého v jednotlivých prvcích objektu map.
`mapped_type`	Definice typu dat uložených v jednotlivých prvcích objektu map.
`pointer`	Typedef pro ukazatel na `const` prvek v mapě.
`reference`	Definice typu odkazu na prvek uložený v objektu map.
`reverse_iterator`	Definice typu obousměrného iterátoru, který může číst nebo upravovat prvek v obráceném objektu map.
`size_type`	Celočíselná definice typu bez znaménka pro počet prvků v objektu map.
`value_type`	Definice typu pro typ objektu, který je uložen jako prvek v objektu map.

Členské funkce

Členová funkce	Popis
`at`	Vyhledá prvek se zadanou hodnotou klíče.
`begin`	Vrátí iterátor, který odkazuje na první prvek v objektu `map`.
`cbegin`	Vrátí iterátor const, který odkazuje na první prvek v objektu `map`.
`cend`	Vrátí konstantní iterátor za koncem.
`clear`	Vymaže všechny prvky .`map`
`contains`^C++20	Zkontrolujte, jestli existuje prvek se zadaným klíčem v objektu `map`.
`count`	Vrátí počet prvků objektu map, jejichž klíč odpovídá klíči zadaného parametrem.
`crbegin`	Vrátí iterátor const, který odkazuje na první prvek v obráceném `map`objektu .
`crend`	Vrátí konstantní iterátor, který odkazuje na umístění za posledním prvkem v obráceném směru `map`.
`emplace`	Vloží prvek vytvořený na místě do objektu `map`.
`emplace_hint`	Vloží prvek vytvořený na místě do objektu `map`, s tipem umístění.
`empty`	Vrátí `true` hodnotu, pokud `map` je prázdná.
`end`	Vrátí iterátor za koncem.
`equal_range`	Vrátí pár iterátorů. První iterátor ve dvojici odkazuje na první prvek v `map` klíči, který je větší než zadaný klíč. Druhý iterátor ve dvojici odkazuje na první prvek v `map` klíči, který je roven nebo větší než klíč.
`erase`	Odebere prvek nebo rozsah prvků v objektu map od zadané pozice.
`find`	Vrátí iterátor, který odkazuje na umístění prvku v `map` klíči, který se rovná zadanému klíči.
`get_allocator`	Vrátí kopii objektu `allocator` , který se používá k sestavení `map`.
`insert`	Vloží prvek nebo rozsah prvků do `map` zadané pozice.
`key_comp`	Vrátí kopii objektu porovnání, který se používá k řazení klíčů v objektu `map`.
`lower_bound`	Vrátí iterátor na první prvek v `map` klíči, který má hodnotu klíče, která je rovna nebo větší než zadaný klíč.
`max_size`	Vrátí maximální délku `map`.
`rbegin`	Vrátí iterátor, který odkazuje na první prvek v obráceném směru `map`.
`rend`	Vrátí iterátor, který odkazuje na umístění za posledním prvkem v obráceném stavu `map`.
`size`	Vrátí počet prvků v sadě `map`.
`swap`	Zamění prvky dvou objektů map.
`upper_bound`	Vrátí iterátor na první prvek v `map` klíči, který má hodnotu klíče, která je větší než zadaný klíč.
`value_comp`	Načte kopii objektu porovnání, který slouží k seřazení hodnot prvků v objektu `map`.

Operátory

Jméno	popis
`operator[]`	Vloží prvek do objektu map se zadanou hodnotou klíče.
`operator=`	Nahradí prvky objektu map kopií jiného objektu map.

`allocator_type`

Typ, který představuje třídu alokátoru pro objekt mapy.

typedef Allocator allocator_type;

Příklad

get_allocator Příklad, který používá allocator_type.

`at`

Vyhledá prvek se zadanou hodnotou klíče.

Type& at(const Key& key);

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

Parametry

key
Hodnota klíče, kterou chcete najít.

Vrácená hodnota

Odkaz na datovou hodnotu nalezeného prvku.

Poznámky

Pokud se hodnota klíče argumentu nenajde, funkce vyvolá objekt třídy out_of_range Class.

Příklad

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

Vrátí iterátor adresování prvního prvku v objektu map.

const_iterator begin() const;

iterator begin();

Vrácená hodnota

Obousměrný iterátor adresující první prvek v map umístění, které je úspěšné, prázdné mapování.

Příklad

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

const Vrátí iterátor, který řeší umístění za posledním prvkem v rozsahu.

const_iterator cbegin() const;

Vrácená hodnota

Obousměrný const iterátor adresuje první prvek v oblasti nebo umístění těsně za koncem prázdné oblasti (pro prázdnou oblast, cbegin() == cend()).

Poznámky

Při návratové cbeginhodnotě nelze upravit prvky v oblasti.

Tuto členská funkce můžete použít místo begin() členské funkce, abyste zajistili, že návratová hodnota je const_iterator. Obvykle se používá ve spojení s klíčovým slovem odpočtu auto typu, jak je znázorněno v následujícím příkladu. V příkladu zvažte Container , že je upravitelný (non- const) kontejner jakéhokoli druhu, který podporuje begin() a cbegin().

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

// i2 is Container<T>::const_iterator

`cend`

const Vrátí iterátor, který řeší umístění za posledním prvkem v rozsahu.

const_iterator cend() const;

Vrácená hodnota

const Obousměrný iterátor s přístupem, který odkazuje těsně za koncem rozsahu.

Poznámky

cend slouží k otestování, zda iterátor předal konec jeho rozsahu.

Tuto členská funkce můžete použít místo end() členské funkce, abyste zajistili, že návratová hodnota je const_iterator. Obvykle se používá ve spojení s klíčovým slovem odpočtu auto typu, jak je znázorněno v následujícím příkladu. V příkladu zvažte Container , že je upravitelný (non- const) kontejner jakéhokoli druhu, který podporuje end() a cend().

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

// i2 is Container<T>::const_iterator

Hodnota vrácená cend hodnotou by neměla být dereferenced.

`clear`

Odstraní všechny prvky objektu map.

void clear();

Příklad

Následující příklad ukazuje použití map::clear členské funkce.

// 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, který poskytuje obousměrný iterátor, který může číst const prvek v objektu map.

typedef implementation-defined const_iterator;

Poznámky

Typ const_iterator nelze použít k úpravě hodnoty elementu.

Definice const_iterator mapování odkazuje na prvky, které jsou objekty value_typetypu pair<constKey, Type>, jehož první člen je klíčem k prvku a jehož druhý člen je mapovaný datum uchovávané prvkem.

Pokud chcete odkazovat const_iteratorcIter na prvek v mapě, použijte -> operátor.

Pro přístup k hodnotě klíče pro prvek použijte cIter ->first, což je ekvivalentní (* cIter). first.

Pokud chcete získat přístup k hodnotě mapovaného data pro prvek, použijte cIter ->second, což je ekvivalentní hodnotě (* cIter). second.

Příklad

begin Příklad, který používá const_iterator.

`const_pointer`

Typ, který poskytuje ukazatel na const prvek v mapě.

typedef typename allocator_type::const_pointer const_pointer;

Poznámky

Typ const_pointer nelze použít k úpravě hodnoty elementu.

Ve většině případů iterator by se měla použít pro přístup k prvkům v objektu mapy.

`const_reference`

Typ, který poskytuje odkaz na const prvek uložený v mapě pro čtení a provádění const operací.

typedef typename allocator_type::const_reference const_reference;

Příklad

// 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, který poskytuje obousměrný iterátor, který může číst libovolný const prvek v objektu map.

typedef std::reverse_iterator<const_iterator> const_reverse_iterator;

Poznámky

Typ const_reverse_iterator nemůže změnit hodnotu elementu a slouží k iteraci mapou obráceně.

Definice const_reverse_iterator mapování odkazuje na prvky, které jsou objekty value_typetypu pair<const Key, Type>, jehož první člen je klíčem k prvku a jehož druhý člen je mapovaný datum uchovávané prvkem.

Pokud chcete odkazovat const_reverse_iterator crIter na prvek v mapě, použijte -> operátor.

Pro přístup k hodnotě klíče pro prvek použijte crIter -first>, což je ekvivalentní (* crIter).first.

Pro přístup k hodnotě mapovaného data pro prvek použijte crIter -second>, což je ekvivalentní (* crIter).first.

Příklad

Podívejte se na příklad rend , jak deklarovat a používat const_reverse_iterator.

`count`

Vrátí počet prvků v mapě, jejichž klíč odpovídá klíči zadanému parametrem.

size_type count(const Key& key) const;

Parametry

key
Hodnota klíče prvků, které se mají shodovat z mapy.

Vrácená hodnota

1, pokud mapa obsahuje prvek, jehož klíč řazení odpovídá klíči parametru; 0, pokud mapa neobsahuje prvek s odpovídajícím klíčem.

Poznámky

Členová funkce vrátí počet prvků x v oblasti.

[ lower_bound(klíč), upper_bound(klíč) )

což je 0 nebo 1 v případě mapy, což je jedinečný asociativní kontejner.

Příklad

Následující příklad ukazuje použití map::count členské funkce.

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

Zkontroluje, jestli existuje prvek se zadaným klíčem v objektu map.

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

Parametry

K
Typ klíče.

key
Hodnota klíče prvku, kterou chcete vyhledat.

Vrácená hodnota

true je-li prvek nalezen v kontejneru; false Jinak.

Poznámky

contains() je nový v jazyce C++20. Pokud ho chcete použít, zadejte možnost kompilátoru /std:c++20 nebo novější.

template<class K> bool contains(const K& key) const Pouze se účastní řešení přetížení, pokud key_compare je transparentní. Další informace najdete v heterogenním vyhledávání v asociativních kontejnerech .

Příklad

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

Vrátí konstantní iterátor adresovaný prvním prvkem v obrácené mapě.

const_reverse_iterator crbegin() const;

Vrácená hodnota

Const reverse obousměrný iterátor adresuje první prvek v obráceném map směru nebo adresování toho, co bylo posledním prvkem v nereverze .map

Poznámky

crbegin se používá s obráceným opakem map , stejně jako begin se používá s map.

S návratovou crbeginmap hodnotou objektu nelze změnit.

crbegin lze použít k iteraci zpět map .

Příklad

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

Vrátí const iterátor, který řeší umístění úspěšné poslední prvek v obrácené mapě.

const_reverse_iterator crend() const;

Vrácená hodnota

Const reverse obousměrný iterátor, který řeší umístění úspěšné poslední prvek v obráceném map směru (umístění, které předchází prvnímu prvku v unreversed map).

Poznámky

crend se používá s obrácenou mapou stejně, jako end se používá s map.

S návratovou crendmap hodnotou objektu nelze změnit.

crend lze použít k otestování, zda reverzní iterátor dosáhl konce jeho map.

Hodnota vrácená crend hodnotou by neměla být dereferenced.

Příklad

// 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 celého čísla se znaménkem, který lze použít k reprezentaci počtu prvků mapy v rozsahu mezi prvky, na které odkazují iterátory.

typedef allocator_type::difference_type difference_type;

Poznámky

Jedná se difference_type o typ vrácený při odečtení nebo zvýšení prostřednictvím iterátorů kontejneru. Obvykle difference_type se používá k reprezentaci počtu prvků v rozsahu [ první, poslední) mezi iterátory first a last, zahrnuje prvek, na který first odkazuje, a rozsah prvků až do, ale nikoli včetně prvku, na který odkazuje last.

Ačkoli difference_type je k dispozici pro všechny iterátory, které splňují požadavky vstupního iterátoru, který zahrnuje třídu obousměrných iterátorů podporovaných reverzibilními kontejnery, jako je sada, odčítání mezi iterátory je podporováno pouze iterátory náhodného přístupu poskytované kontejnerem náhodného přístupu, jako je vektor.

Příklad

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

Vloží prvek vytvořený na místě (neprovádí se operace kopírování nebo přesunutí) do mapy.

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

Parametry

args
Argumenty předané k vytvoření prvku, který se vloží do mapy, pokud již neobsahuje prvek, jehož hodnota je ekvivalentní seřazena.

Vrácená hodnota

Jejíž pairbool komponenta je true v případě, že byla vložena, a false pokud mapa již obsahoval prvek ekvivalentní hodnoty v pořadí. Komponenta iterátoru dvojice návratových hodnot odkazuje na nově vložený prvek, pokud bool je komponenta pravdivá, nebo na existující prvek, pokud je komponenta bool nepravda.

Chcete-li získat přístup k iterátoru pairprsoučásti , použijte pr.first; k jeho dereference, použijte *pr.first. Pro přístup ke komponentě bool použijte pr.second. Příklad naleznete v ukázce kódu dále v tomto článku.

Poznámky

Tato funkce zneplatní žádné iterátory ani odkazy.

Pokud při emplacementu dojde k výjimce, stav kontejneru se nezmění.

Prvek value_type je dvojice, takže hodnota prvku bude seřazený pár s první komponentou, která se rovná hodnotě klíče a druhá komponenta rovna datové hodnotě prvku.

Příklad

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

Vloží prvek vytvořený na místě (neprovádí se žádné operace kopírování nebo přesunutí) s nápovědou k umístění.

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

Parametry

args
Argumenty předané k vytvoření elementu, který se má vložit do mapy, pokud mapování již tento prvek neobsahuje nebo obecněji, pokud již neobsahuje prvek, jehož klíč je ekvivalentní seřazen.

where
Místo zahájení vyhledání správného bodu vložení. (Pokud tento bod bezprostředně předchází místu, kde může dojít k vložení v amortizovaném konstantním čase místo logaritmického času.)

Vrácená hodnota

Iterátor na nově vložený prvek.

Pokud vložení selhalo, protože prvek již existuje, vrátí iterátor existujícímu prvku s jeho klíčem.

Poznámky

Tato funkce zneplatní žádné iterátory ani odkazy.

Pokud při emplacementu dojde k výjimce, stav kontejneru se nezmění.

Prvek value_type je dvojice, takže hodnota prvku bude seřazený pár s první komponentou, která se rovná hodnotě klíče a druhá komponenta rovna datové hodnotě prvku.

Příklad

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

Testuje, jestli je mapa prázdná.

bool empty() const;

Vrácená hodnota

true je-li mapa prázdná; false pokud je mapa neprázdná.

Příklad

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

Vrátí iterátor za koncem.

const_iterator end() const;

iterator end();

Vrácená hodnota

Poslední iterátor. Pokud je mapa prázdná, pak map::end() == map::begin().

Poznámky

end slouží k otestování, zda iterátor předal konec mapy.

Hodnota vrácená end hodnotou by neměla být dereferenced.

Příklad kódu najdete v tématu map::find.

`equal_range`

Vrátí dvojici iterátorů, které představují lower_bound klíč a upper_bound klíč.

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

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

Parametry

key
Hodnota klíče argumentu, která se má porovnat s klíčem řazení prvku z prohledávané mapy.

Vrácená hodnota

Pokud chcete získat přístup k prvnímu iterátoru dvojice pr vrácené členovou funkcí, použijte pr. nejprve a chcete-li odvodit dolní mez iterátoru, použijte *( pr. první). Pokud chcete získat přístup k druhému iterátoru dvojice pr vrácené členovou funkcí, použijte pr. a chcete-li převést horní mez iterátoru, použijte *( pr. druhý).

Příklad

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

Odebere prvek nebo oblast prvků v mapě ze zadaných pozic nebo odebere prvky, které odpovídají zadanému klíči.

iterator erase(
    const_iterator Where);

iterator erase(
    const_iterator First,
    const_iterator Last);

size_type erase(
    const key_type& Key);

Parametry

Where
Pozice prvku, který má být odebrán.

First
Pozice prvního prvku, který má být odebrán.

Last
Pozice bezprostředně za posledním prvkem, který má být odebrán.

Key
Hodnota klíče prvků, které mají být odebrány.

Vrácená hodnota

U prvních dvou členských funkcí určuje obousměrný iterátor, který určuje první prvek, který je nad rámec všech odebraných prvků, nebo prvek, který je koncem mapy, pokud žádný takový prvek neexistuje.

U třetí členské funkce vrátí počet prvků, které byly z mapy odebrány.

Příklad

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

Vrátí iterátor, který odkazuje na umístění prvku v mapě, která má klíč ekvivalentní zadanému klíči.

iterator find(const Key& key);

const_iterator find(const Key& key) const;

Parametry

key
Hodnota klíče, která se má shodovat s klíčem řazení prvku z prohledávané mapy.

Vrácená hodnota

Iterátor, který odkazuje na umístění prvku se zadaným klíčem, nebo umístění úspěšné poslední prvek v map (map::end()), pokud se pro klíč nenajde žádná shoda.

Poznámky

Členská funkce vrátí iterátor, který odkazuje na prvek, jehož map klíč řazení je ekvivalentní klíči argumentu pod binárním predikátem, který indukuje řazení na základě porovnání.

Pokud je vrácená hodnota find přiřazena k objektu const_iteratormapy, nelze upravit. Pokud je vrácená hodnota find přiřazena k objektu iteratormap, lze upravit objekt mapy.

Příklad

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

Vrátí kopii objektu alokátoru použitého k vytvoření mapy.

allocator_type get_allocator() const;

Vrácená hodnota

Alokátor používaný mapou.

Poznámky

Alokátory pro třídu mapování určují, jak třída spravuje úložiště. Výchozí alokátory dodávané s třídami kontejneru standardní knihovny C++ jsou dostatečné pro většinu programovacích potřeb. Psaní a používání vlastní třídy alokátoru je pokročilé téma jazyka C++.

Příklad

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

Vloží prvek nebo oblast prvků 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
Hodnota prvku, který se má vložit do mapy, pokud již neobsahuje prvek, jehož klíč je odpovídajícím způsobem seřazen.

Where
Místo zahájení vyhledání správného bodu vložení. (Pokud tento bod bezprostředně předchází Where, může se místo logaritmického času objevit vložení v amortizovaném konstantním čase.)

ValTy
Parametr šablony, který určuje typ argumentu, který může mapa použít k vytvoření elementu value_type, a perfect-forwards Val jako argument.

First
Pozice prvního prvku, který chcete zkopírovat.

Last
Pozice bezprostředně za posledním prvkem, který chcete zkopírovat.

InputIterator
Argument funkce šablony, který splňuje požadavky vstupního iterátoru , který odkazuje na prvky typu, které lze použít k vytvoření value_type objektů.

IList
Ze initializer_list kterého chcete prvky zkopírovat.

Vrácená hodnota

Členské funkce s jedním prvkem (1) a (2), vrátí pair hodnotu, jejíž bool komponenta je pravdivá, pokud byla vložena, a nepravda, pokud mapa již obsahoval prvek, jehož klíč měl ekvivalentní hodnotu v pořadí. Komponenta iterátoru dvojice návratových hodnot odkazuje na nově vložený prvek, pokud bool je komponenta pravdivá, nebo na existující prvek, pokud je komponenta bool nepravda.

Členské funkce s jedním prvkem s nápovědou (3) a (4) vrátí iterátor, který odkazuje na pozici, kde byl nový prvek vložen do mapy, nebo pokud prvek s ekvivalentním klíčem již existuje, existující prvek.

Poznámky

Touto funkcí nejsou zneplatněny žádné iterátory, ukazatele ani odkazy.

Během vkládání pouze jednoho prvku, pokud je vyvolán výjimka, stav kontejneru se nezmění. Pokud je při vkládání více prvků vyvolána výjimka, kontejner zůstane v neurčeném, ale platném stavu.

Pokud chcete získat přístup ke komponentě iterátoru pairpr vrácené členské funkce s jedním prvkem, použijte pr.first; pro dereference iterátoru ve vrácené dvojici použijte *pr.first, a to tím, že vám poskytne prvek. Pro přístup ke komponentě bool použijte pr.second. Příklad naleznete v ukázce kódu dále v tomto článku.

Kontejner value_type je typedef, který patří do kontejneru a pro mapování map<K, V>::value_type je pair<const K, V>. Hodnota prvku je seřazená dvojice, ve které je první komponenta rovna hodnotě klíče a druhá komponenta je rovna datové hodnotě prvku.

Členová funkce rozsahu (5) vloží sekvenci hodnot prvků do mapy, která odpovídá každému prvku adresovanému iterátorem v oblasti [First, Last); proto Last se nevloží. Členská funkce kontejneru end() se vztahuje k pozici hned za posledním prvkem v kontejneru, například příkaz m.insert(v.begin(), v.end()); se pokusí vložit všechny prvky v do m. Vkládají se pouze prvky, které v rozsahu obsahují jedinečné hodnoty. Duplicitní hodnoty jsou ignorovány. Chcete-li sledovat, které prvky jsou odmítnuty, použijte jednoprvkovou verzi funkce insert.

Funkce člena seznamu inicializátoru (6) používá initializer_list ke kopírování prvků do mapy.

Vložení prvku vytvořeného na místě – to znamená, že se neprovádí žádné operace kopírování nebo přesunutí – viz map::emplace a map::emplace_hint.

Příklad

// 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, který poskytuje obousměrný iterátor, který může číst nebo upravovat libovolný prvek v mapě.

typedef implementation-defined iterator;

Poznámky

Iterátor definovaný mapováním odkazuje na prvky, které jsou objekty value_typetypu pair<const Key, Type>, jehož prvním členem je klíč k prvku a jehož druhý člen je mapovaný datum uchovávané prvkem.

Pokud chcete převést iterátor iterátor odkazující na prvek v mapě, použijte -> operátor.

Chcete-li získat přístup k hodnotě klíče pro prvek, použijte Iter->first, což je ekvivalentní (*Iter).first. Pro přístup k hodnotě mapovaného data pro prvek použijte Iter->second, což je ekvivalentní (*Iter).second.

Příklad

begin Příklad, jak deklarovat a používat iterator.

`key_comp`

Načte kopii objektu porovnání použitého k seřazení klíčů v mapě.

key_compare key_comp() const;

Vrácená hodnota

Vrátí objekt funkce, který mapa používá k seřazení jeho prvků.

Poznámky

Uložený objekt definuje členovu funkci.

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

vrátí true , pokud left předchází a není rovno right v pořadí řazení.

Příklad

// 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, který poskytuje objekt funkce, který může porovnat dva klíče řazení k určení relativního pořadí dvou prvků v objektu map.

typedef Traits key_compare;

Poznámky

key_compare je synonymem parametru Traitsšablony .

Další informace naleznete Traitsv map tématu Třída .

Příklad

key_comp Příklad, jak deklarovat a používat key_compare.

`key_type`

Typ, který popisuje klíč řazení uložený v každém prvku mapy.

typedef Key key_type;

Poznámky

key_type je synonymem parametru Keyšablony .

Další informace naleznete Keyv části Poznámky tématu předmětumap.

Příklad

value_type Příklad, jak deklarovat a používat key_type.

`lower_bound`

Vrátí iterátor na první prvek v mapě s hodnotou klíče, která je rovna nebo větší než zadaný klíč.

iterator lower_bound(const Key& key);

const_iterator lower_bound(const Key& key) const;

Parametry

key
Hodnota klíče argumentu, která se má porovnat s klíčem řazení prvku z prohledávané mapy.

Vrácená hodnota

const_iterator Nebo iterator adresující umístění prvku v mapě, který se shoduje s klíčem, který je roven nebo větší než klíč argumentu, nebo který řeší umístění úspěšného posledního prvku v map případě, že se pro klíč nenajde žádná shoda.

Pokud je vrácená hodnota lower_bound přiřazena k objektu const_iteratormapy, nelze upravit. Pokud je vrácená hodnota lower_bound přiřazena k objektu iteratormapy, lze upravit.

Příklad

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

Vytvoří mapu, která je prázdná nebo která je kopií všech nebo částí jiné 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
Třída alokátoru úložiště, která se má použít pro tento objekt mapy, který má výchozí hodnotu Allocator.

Comp
Porovnávací funkce typu const Traits , která se používá k seřazení prvků v mapsouboru , který je výchozí hash_compare.

Right
Objekt map, ze kterého je kopií vytvořen objekt set.

First
Pozice prvního prvku v oblasti prvků, které se mají zkopírovat.

Last
Pozice prvního prvku nad rozsah prvků, které se mají zkopírovat.

IList
Initializer_list, ze kterého mají být prvky zkopírovány.

Poznámky

Všechny konstruktory ukládají typ objektu alokátoru, který spravuje úložiště paměti pro mapu a které lze později vrátit voláním get_allocator. Parametr allocator je často v deklaraci třídy vynechán a makra předběžného zpracování jsou použita k nahrazení alternativních alokátorů.

Všechny konstruktory inicializují svou mapu.

Všechny konstruktory ukládají objekt funkce typu Traits, který se používá k vytvoření pořadí mezi klíči mapy a které lze později vrátit voláním key_comp.

První tři konstruktory určují prázdnou počáteční mapu, druhou určující typ porovnávací funkce (Comp), která se má použít při stanovení pořadí prvků, a třetí explicitně specifikuje typ alokátoru (Al), který se má použít. Klíčové slovo explicit potlačí některé druhy automatického převodu typu.

Čtvrtý konstruktor určuje kopii mapy Right.

Pátý konstruktor určuje kopii mapy přesunutím Right.

6., 7. a 8. konstruktory používají initializer_list k kopírování členů.

Další tři konstruktory zkopírují rozsah [First, Last) mapy s rostoucí explicitností při určení typu porovnávací funkce třídy Traits a alokátoru.

Příklad

// 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, který představuje data uložená v mapě.

typedef Type mapped_type;

Poznámky

mapped_type Typ je synonymem pro parametr šablony type třídy.

Další informace naleznete Typev map tématu Třída .

Příklad

value_type Příklad, jak deklarovat a používat mapped_type.

`max_size`

Vrátí maximální délku objektu map.

size_type max_size() const;

Vrácená hodnota

Maximální možná délka mapy.

Příklad

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

Vloží prvek do objektu map se zadanou hodnotou klíče.

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

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

Parametry

key
Hodnota klíče elementu, který se má vložit.

Vrácená hodnota

Odkaz na hodnotu dat vloženého prvku.

Poznámky

Pokud se hodnota klíče argumentu nenajde, vloží se spolu s výchozí hodnotou datového typu.

operator[] lze použít k vložení prvků do mapy m , kde m[key] = DataValue;DataValue je hodnota mapped_type prvku s hodnotou keyklíče .

Při použití operator[] k vložení prvků vrácený odkaz nezoznačuje, zda vložení mění existující prvek nebo vytváří nový. Členské funkce find a insert lze je použít k určení, zda prvek se zadaným klíčem již existuje před vložením.

Příklad

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

Nahradí prvky objektu map kopií jiného objektu map.

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

Parametry

right
Zkopírovaná map do souboru map.

Poznámky

Po vymazání všech existujících prvků v souboru map, operator= buď zkopíruje nebo přesune obsah right do mapy.

Příklad

// 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, který poskytuje ukazatel na prvek v mapě.

typedef typename allocator_type::pointer pointer;

Poznámky

Typ pointer lze použít k úpravě hodnoty elementu.

Ve většině případů iterator by se měla použít pro přístup k prvkům v objektu mapy.

Rbegin

Vrátí iterátor adresovaný prvním prvkem v obrácené mapě.

const_reverse_iterator rbegin() const;

reverse_iterator rbegin();

Vrácená hodnota

Reverzní obousměrný iterátor adresovaný prvním prvkem v obrácené mapě nebo adresování toho, co bylo posledním prvkem v nereverzní mapě.

Poznámky

rbegin se používá s obrácenou mapou stejně, jako begin se používá s mapou.

Pokud je vrácená hodnota rbegin přiřazena k objektu const_reverse_iteratormapy, nelze upravit. Pokud je vrácená hodnota rbegin přiřazena k objektu reverse_iterator, lze upravit objekt mapy.

rbegin lze použít k iteraci pomocí mapy zpět.

Příklad

// 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, který poskytuje odkaz na prvek uložený v mapě.

typedef typename allocator_type::reference reference;

Příklad

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

Vrátí iterátor, který řeší umístění úspěšné poslední prvek v obrácené mapě.

const_reverse_iterator rend() const;

reverse_iterator rend();

Vrácená hodnota

Reverzní obousměrný iterátor, který řeší umístění úspěšné poslední prvek v obrácené mapě (umístění, které předchází prvnímu prvku v nereverzní mapě).

Poznámky

rend se používá s obrácenou mapou stejně, jako end se používá s mapou.

Pokud je vrácená hodnota rend přiřazena k objektu const_reverse_iteratormapy, nelze upravit. Pokud je vrácená hodnota rend přiřazena k objektu reverse_iterator, lze upravit objekt mapy.

rend lze použít k otestování, zda reverzní iterátor dosáhl konce mapy.

Hodnota vrácená rend hodnotou by neměla být dereferenced.

Příklad

// 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, který poskytuje obousměrný iterátor, který může číst nebo upravovat prvek v obrácené mapě.

typedef std::reverse_iterator<iterator> reverse_iterator;

Poznámky

Typ reverse_iterator nemůže změnit hodnotu elementu a slouží k iteraci mapou obráceně.

Definice reverse_iterator mapování odkazuje na prvky, které jsou objekty value_typetypu pair<const Key, Type>, jehož první člen je klíčem k prvku a jehož druhý člen je mapovaný datum uchovávané prvkem.

Pokud chcete dereference reverse_iteratorrIter odkazující na prvek v mapě, použijte -> operátor.

Pro přístup k hodnotě klíče pro prvek použijte rIter ->first, což je ekvivalentní (* rIter). nejprve. Pokud chcete získat přístup k hodnotě mapovaného data pro prvek, použijte rIter hodnotu ->second, která je ekvivalentní hodnotě (* rIter). nejprve.

Příklad

rbegin Příklad, jak deklarovat a používat reverse_iterator.

`size`

Vrátí počet prvků v sadě map.

size_type size() const;

Vrácená hodnota

Aktuální délka mapy.

Příklad

Následující příklad ukazuje použití map::size členské funkce.

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

Typ celého čísla bez znaménka, který může představovat počet prvků v mapě.

typedef typename allocator_type::size_type size_type;

Příklad

Podívejte se na příklad size , jak deklarovat a používat size_type.

swap

Zamění prvky dvou objektů map.

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

Parametry

right
Mapa argumentů poskytující prvky, které mají být prohozeny s cílovou mapou.

Poznámky

Členová funkce zneplatňuje žádné odkazy, ukazatele nebo iterátory, které označují prvky ve dvou mapách, jejichž prvky se vyměňují.

Příklad

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

Vrátí iterátor na první prvek v mapě, který s klíčem má hodnotu větší než zadaný klíč.

iterator upper_bound(const Key& key);

const_iterator upper_bound(const Key& key) const;

Parametry

key
Hodnota klíče argumentu, která se má porovnat s hodnotou klíče řazení prvku z prohledávané mapy.

Vrácená hodnota

const_iterator Nebo iterator adresující umístění elementu v mapě, která má klíč větší než klíč argumentu, nebo která řeší umístění úspěšného posledního map prvku v případě, že se pro klíč nenajde žádná shoda.

Pokud je vrácená hodnota přiřazena k objektu const_iteratormapy, nelze upravit. Pokud je vrácená hodnota přiřazena k objektu iteratormapy, lze upravit.

Příklad

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

Členová funkce vrátí objekt funkce, který určuje pořadí prvků v mapě porovnáním jejich klíčových hodnot.

value_compare value_comp() const;

Vrácená hodnota

Vrátí objekt funkce porovnání, který mapa používá k seřazení jeho prvků.

Poznámky

V případě mapování m jsou dva prvky e1(k1, d1) a e2(k2; d2) objekty typu value_type, kde k1 a k1 jsou jejich klíči typu key_type a d1 a d2 jsou jejich data typu mapped_type, pak m.value_comp(e1, e2) je ekvivalentní m.key_comp(k1, k2). Uložený objekt definuje členovou funkci.

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

vrátí true , pokud hodnota left klíče předchází a není rovna hodnotě right klíče v pořadí řazení.

Příklad

// 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 objektu uloženého jako prvek v mapě.

typedef pair<const Key, Type> value_type;

Příklad

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

Viz také

Kontejnery
Bezpečný přístup z více vláken ve standardní knihovně C++
Standardní knihovna C++ – referenční dokumentace

Sdílet prostřednictvím

map Třída

Syntaxe

Parametry

Poznámky

Členové

Konstruktory

Typedefs

Členské funkce

Operátory

allocator_type

Příklad

at

Parametry

Vrácená hodnota

Poznámky

Příklad

begin

Vrácená hodnota

Příklad

cbegin

Vrácená hodnota

Poznámky

cend

Vrácená hodnota

Poznámky

clear

Příklad

const_iterator

Poznámky

Příklad

const_pointer

Poznámky

const_reference

Příklad

const_reverse_iterator

Poznámky

Příklad

count

Parametry

Vrácená hodnota

Poznámky

Příklad

contains

Parametry

Vrácená hodnota

Poznámky

Příklad

crbegin

Vrácená hodnota

Poznámky

Příklad

crend

Vrácená hodnota

Poznámky

Příklad

difference_type

Poznámky

Příklad

emplace

Parametry

Vrácená hodnota

Poznámky

Příklad

emplace_hint

Parametry

Vrácená hodnota

Poznámky

Příklad

empty

Vrácená hodnota

Příklad

end

Vrácená hodnota

Poznámky

equal_range

Parametry

Vrácená hodnota

Příklad

erase

`map` Třída

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