`map` osztály

Olyan gyűjteményből származó adatok tárolására és lekérésére szolgál, amelyekben minden elem egy olyan pár, amelynek adatértéke és rendezési kulcsa is van. A kulcs értéke egyedi, és az adatok automatikus rendezésére szolgál.

A térkép elemeinek értéke közvetlenül módosítható. A kulcs értéke állandó, és nem módosítható. Ehelyett törölni kell a régi elemekhez társított kulcsértékeket, és új kulcsértékeket kell beszúrni az új elemekhez.

Szemantika

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

Paraméterek

Key
A kulcs adattípusa, amely a map.

Type
A maptárolandó elem adattípusa.

Traits
Az a típus, amely egy függvényobjektumot biztosít, amely rendezési kulcsként összehasonlíthat két elemértéket a relatív sorrend meghatározásához a map. Ez az argumentum nem kötelező, és a bináris predikátum less<Key> az alapértelmezett érték.

A C++14-ben engedélyezheti a heterogén kereséseket a std::less<> típusparamétereket nem tartalmazó predikátum megadásával. További információt az Asszociatív tárolók heterogén keresésében talál.

Allocator
Az a típus, amely a tárolt kiosztó objektumot jelöli, amely a térkép lefoglalásával és a memória felszabadítással kapcsolatos részleteket foglalja magában. Ez az argumentum nem kötelező, és az alapértelmezett érték allocator<pair<const Key, Type> >.

Megjegyzések

A C++ standard kódtár térképosztálya a következő:

Változó méretű tároló, amely hatékonyan kéri le az elemértékeket a társított kulcsértékek alapján.
Reverzibilis, mert kétirányú iterátorokat biztosít az elemek eléréséhez.
Rendezve, mert elemeit kulcsértékek rendezik egy megadott összehasonlító függvény szerint.
Egyedülálló. mivel minden elemének egyedi kulccsal kell rendelkeznie.
Pár-asszociatív tároló, mert az elemadat-értékei eltérnek a kulcsértékektől.
Osztálysablon, mert az általa biztosított funkciók általánosak és függetlenek az elem- vagy kulcstípustól. Az elemekhez és kulcsokhoz használt adattípusok paraméterként vannak megadva az osztálysablonban az összehasonlító függvénnyel és az elosztóval együtt.

A térképosztály által biztosított iterátor kétirányú iterátor, de az insertmap osztálytag függvények olyan verziókkal rendelkeznek, amelyek sablonparaméterekként egy gyengébb bemeneti iterátort vesznek igénybe, amelynek működési követelményei kevesebbek, mint a kétirányú iterátorok osztálya által garantáltak. A különböző iterátorfogalmak a funkciójuk finomításával kapcsolódnak. Minden iterátor-fogalom saját követelményekkel rendelkezik, és a vele dolgozó algoritmusokat ezeknek a követelményeknek kell korlátozniuk. Előfordulhat, hogy a bemeneti iterátor egy objektumra hivatkozik, és a sorozat következő iterátorára lehet növelni.

Javasoljuk, hogy a tárolótípust az alkalmazás által igényelt keresés és beszúrás típusára alapozza. Az asszociatív tárolók keresési, beszúrási és eltávolítási műveletekhez vannak optimalizálva. A műveleteket kifejezetten támogató tagfüggvények a legrosszabb esetben hajtják végre őket, amely arányos a tárolóban lévő elemek számának logaritmusával. Az elemek beszúrása nem érvényteleníti az iterátorokat, és az elemek eltávolítása csak azokat az iterátorokat érvényteleníti, amelyek kifejezetten az eltávolított elemekre mutatnak.

Azt javasoljuk, hogy a térképet a választott asszociatív tárolóvá tegye, ha az alkalmazás kielégíti az értékeket kulcsokhoz társító feltételeket. Az ilyen típusú struktúra modellje az egyedileg előforduló kulcsszavak rendezett listája, amelyek a definíciókat tartalmazó társított sztringértékekkel rendelkeznek. Ha egy szó több helyes definícióval is rendelkezik, így a kulcs nem egyedi, akkor egy többtérképes tároló lesz a választott tároló. Ha csak a szavak listája van tárolva, akkor egy készlet lenne a megfelelő tároló. Ha a szavak több előfordulása is engedélyezett, akkor a többhalmaz megfelelő lenne.

A térkép egy tárolt függvény típusú objektum meghívásával rendeli meg a vezérlő elemeit key_compare. Ez a tárolt objektum egy összehasonlító függvény, amely a key_comp metódus meghívásával érhető el. A rendszer általában két adott elemet hasonlít össze annak meghatározásához, hogy az egyik kisebb-e a másiknál, vagy egyenértékűek-e. Az összes elem összehasonlításakor a rendszer a nem egyenértékű elemek rendezett sorozatát hozza létre.

Megjegyzés:

Az összehasonlító függvény egy bináris predikátum, amely a standard matematikai értelemben vett szigorú gyenge rendezést indukálja. A bináris f(x;y) predikátum olyan függvényobjektum, amely két x és y argumentumobjektummal rendelkezik, és a függvény értéke true vagy false. A halmazra vonatkozó sorrend szigorúan gyenge rendezés, ha a bináris predikátum irreflexív, antiszimmetrikus és tranzitív, és ha az egyenértékűség tranzitív, akkor két x és y objektum akkor azonos, ha az f(x,y) és az f(y,x) falseis azonos. Ha a kulcsok közötti egyenlőség erősebb feltétele felváltja az egyenértékűséget, a rendezés teljes lesz (abban az értelemben, hogy az összes elem egymáshoz képest van rendezve), és a megfelelt kulcsok nem lesznek megkülönböztethetők egymástól.

A C++14-ben engedélyezheti a heterogén kereséseket a std::less<> típusparamétereket nem tartalmazó predikátum vagy std::greater<> predikátum megadásával. További információt az Asszociatív tárolók heterogén keresésében talál.

Tagok

Konstruktorok

Név	Leírás
`map`	Létrehoz egy listát egy adott méretről vagy egy adott érték elemeiről, vagy egy adott `allocator` vagy más térkép másolatáról.

Typedefs

Név	Leírás
`allocator_type`	A térképobjektum osztályának típusdefje `allocator` .
`const_iterator`	Egy kétirányú iterátor típusdefje, amely képes beolvasni egy `const` elemet a `map`.
`const_pointer`	A térkép egy `const` elemére mutató mutató típusdefje.
`const_reference`	A térképen tárolt, olvasási és műveletek elvégzésére `const` szolgáló elemre mutató hivatkozás típusdefiniációja`const`.
`const_reverse_iterator`	Olyan típus, amely kétirányú iterátort biztosít, amely képes beolvasni `const` a `map`.
`difference_type`	Aláírt egész számtípus a térkép elemeinek számához az iterátorok által mutatott elemek közötti tartományban.
`iterator`	Egy kétirányú iterátor típusdefje, amely képes a térkép bármely elemének olvasására vagy módosítására.
`key_compare`	Egy függvényobjektum típusdefje, amely két rendezési kulcsot hasonlít össze a függvény két elemének `map`relatív sorrendjének meghatározásához.
`key_type`	A térkép egyes elemeiben tárolt rendezési kulcs típusdefje.
`mapped_type`	A térkép egyes elemeiben tárolt adatok típusdefiniálása.
`pointer`	A térkép egy `const` elemére mutató mutató típusdefje.
`reference`	Egy térképen tárolt elemre mutató hivatkozás típusdefje.
`reverse_iterator`	Egy kétirányú iterátor típusdefje, amely képes olvasni vagy módosítani egy elemet egy fordított térképen.
`size_type`	A térkép elemeinek számához tartozó aláíratlan egész számtípus
`value_type`	A térképen elemként tárolt objektum típusdefje.

Tagfüggvények

Tagfüggvény	Leírás
`at`	Megkeresi a megadott kulcsértékkel rendelkező elemet.
`begin`	Egy iterátort ad vissza, amely a `map`.
`cbegin`	Egy konstans iterátort ad vissza, amely a `map`.
`cend`	Egy konstanst ad vissza a véges iterátoron.
`clear`	Törli a `map`összes elemét.
`contains` ^C++20	Ellenőrizze, hogy van-e a megadott kulccsal rendelkező elem a `map`.
`count`	Visszaadja a térkép azon elemeinek számát, amelyek kulcsa megegyezik a paraméterben megadott kulccsal.
`crbegin`	Egy konstans iterátort ad `map`vissza, amely egy fordított elem első elemére mutat.
`crend`	Egy konstans iterátort ad `map`vissza, amely a fordított elem utolsó eleme utáni helyre mutat.
`emplace`	A helyére épített elemet szúr be a `map`.
`emplace_hint`	Beszúr egy helyben létrehozott elemet a `map`helyére egy elhelyezési tipptel.
`empty`	Üres értéket `true` ad `map` vissza.
`end`	A múlt-the-end iterátort adja vissza.
`equal_range`	Egy iterátorpárt ad vissza. A pár első iterátora egy adott kulcsnál nagyobb kulccsal rendelkező kulcs első elemére `map` mutat. A pár második iterátora a kulcs első elemére `map` mutat, amely egyenlő vagy nagyobb, mint a kulcs.
`erase`	Eltávolít egy elemet vagy elemtartományt a térképen a megadott pozíciókból.
`find`	Egy olyan iterátort ad vissza, amely egy adott kulccsal egyenlő kulccsal rendelkező elem `map` helyére mutat.
`get_allocator`	A `allocator`létrehozásához használt `map` objektum másolatát adja vissza.
`insert`	Elem vagy elemtartomány beszúrása egy `map` adott pozícióba.
`key_comp`	A kulcsok rendeléséhez használt összehasonlító objektum másolatát adja vissza.`map`
`lower_bound`	Egy iterátort ad vissza egy olyan elem első eleméhez `map` , amelynek kulcsértéke egyenlő vagy nagyobb, mint egy adott kulcs.
`max_size`	A `map`maximális hosszát adja vissza.
`rbegin`	Egy olyan iterátort ad `map`vissza, amely egy fordított elem első elemére mutat.
`rend`	Egy olyan iterátort ad `map`vissza, amely a fordított elem utolsó eleme utáni helyre mutat.
`size`	A `map`elemeinek számát adja vissza.
`swap`	Két térkép elemeit cseréli le.
`upper_bound`	Egy iterátort ad vissza egy olyan elem első eleméhez `map` , amelynek kulcsértéke nagyobb, mint egy adott kulcs.
`value_comp`	Lekéri annak az összehasonlító objektumnak a másolatát `map`, amely az elemértékek egy .

Működtetők

Név	Leírás
`operator[]`	Egy adott kulcsértékkel rendelkező elemet szúr be egy térképbe.
`operator=`	A térkép elemeit lecseréli egy másik térkép másolatára.

`allocator_type`

A leképezési objektum kiosztóosztályát jelképező típus.

typedef Allocator allocator_type;

példa

Lásd a get_allocator példát egy példát, amely használja allocator_type.

`at`

Egy megadott kulcsértékkel rendelkező elemet keres.

Type& at(const Key& key);

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

Paraméterek

key
A keresendő kulcsérték.

Visszaadott érték

Hivatkozás a talált elem adatértékére.

Megjegyzések

Ha az argumentumkulcs értéke nem található, akkor a függvény egy osztályobjektumotout_of_range dob.

példa

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

Egy iterátort ad vissza, amely a mapelső elemét kezeli.

const_iterator begin() const;

iterator begin();

Visszaadott érték

Egy kétirányú iterátor, amely az üres térkép első elemét map vagy helyét kezeli.

példa

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

Egy const iterátort ad vissza, amely a tartomány utolsó elemén túli helyet kezeli.

const_iterator cbegin() const;

Visszaadott érték

Kétirányú const iterátor, amely a tartomány első elemét kezeli, vagy az üres tartomány végén túli helyet (üres tartomány cbegin() == cend()esetén).

Megjegyzések

A cbeginvisszatérési értékével a tartomány elemei nem módosíthatók.

Ezt a tagfüggvényt a begin() tagfüggvény helyett használhatja annak garantálásához, hogy a visszatérési érték const_iterator. Általában a auto típusú levonás kulcsszóval együtt használják, ahogy az alábbi példában is látható. A példában a Container egy módosítható (nem const) tárolónak tekinti, amely támogatja a begin() és cbegin().

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

// i2 is Container<T>::const_iterator

`cend`

Egy const iterátort ad vissza, amely a tartomány utolsó elemén túli helyet kezeli.

const_iterator cend() const;

Visszaadott érték

Kétirányú const hozzáférésű iterátor, amely a tartomány végén túlra mutat.

Megjegyzések

cend annak ellenőrzésére szolgál, hogy egy iterátor teljesítette-e a tartomány végét.

Ezt a tagfüggvényt a end() tagfüggvény helyett használhatja annak garantálásához, hogy a visszatérési érték const_iterator. Általában a auto típusú levonás kulcsszóval együtt használják, ahogy az alábbi példában is látható. A példában a Container egy módosítható (nem const) tárolónak tekinti, amely támogatja a end() és cend().

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

// i2 is Container<T>::const_iterator

A visszaadott cend értéket nem szabad elhalasztani.

`clear`

Törli a térkép összes elemét.

void clear();

példa

Az alábbi példa a tagfüggvény használatát map::clear mutatja be.

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

Olyan típus, amely kétirányú iterátort biztosít, amely képes beolvasni egy const elemet a map.

typedef implementation-defined const_iterator;

Megjegyzések

Egy const_iterator típus nem használható elem értékének módosítására.

A const_iterator leképezés által definiált elemek olyan elemekre mutatnak, amelyek olyan típusú objektumok value_type, pair<constKey, Type>amelyeknek az első tagja az elem kulcsa, a második tag pedig az elem által birtokolt leképezési datum.

const_iterator cIter Ha egy térkép egy elemére mutat, használja az operátort->.

Az elem kulcsának értékéhez való hozzáféréshez használja cIter a ->first értéket, amely egyenértékű a (* cIter) értékkel. first.

Az elemhez hozzárendelt datum értékének eléréséhez használja cIter a ->second értéket, amely egyenértékű a (* cIter) értékkel. second.

példa

Lásd a begin példát egy példát, amely használja const_iterator.

`const_pointer`

Olyan típus, amely mutatót ad a térkép egy const eleméhez.

typedef typename allocator_type::const_pointer const_pointer;

Megjegyzések

Egy const_pointer típus nem használható elem értékének módosítására.

A legtöbb esetben egy iterator térképobjektum elemeinek elérésére van szükség.

`const_reference`

Olyan típus, amely egy térképen tárolt elemre const mutató hivatkozást tartalmaz olvasási és műveletek elvégzéséhez const .

typedef typename allocator_type::const_reference const_reference;

példa

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

Olyan típus, amely kétirányú iterátort biztosít, amely képes beolvasni const a map.

typedef std::reverse_iterator<const_iterator> const_reverse_iterator;

Megjegyzések

Egy típus const_reverse_iterator nem tudja módosítani egy elem értékét, és a térképen fordított módon történő iterálásra szolgál.

A const_reverse_iterator leképezés által definiált elemek olyan elemekre mutatnak, amelyek olyan típusú objektumok value_type, pair<const Key, Type>amelyeknek az első tagja az elem kulcsa, a második tag pedig az elem által birtokolt leképezési datum.

const_reverse_iterator crIter Ha egy térkép egy elemére mutat, használja az operátort->.

Az elem kulcsértékének eléréséhez használja crIter a ->firstértéket, amely egyenértékű a (* crIter)first értékkel.

Az elemhez hozzárendelt datum értékének eléréséhez használja crIter a ->second, amely egyenértékű a (* crIter)first értékkel.

példa

A deklarálásához és használatához rendlásd a példátconst_reverse_iterator.

`count`

Visszaadja a térkép azon elemeinek számát, amelyek kulcsa egy paraméter által megadott kulccsal egyezik.

size_type count(const Key& key) const;

Paraméterek

key
A térképen egyeztetendő elemek kulcsértéke.

Visszaadott érték

1, ha a térkép olyan elemet tartalmaz, amelynek rendezési kulcsa megegyezik a paraméterkulcséval; 0, ha a térkép nem tartalmaz egyező kulccsal rendelkező elemet.

Megjegyzések

A tagfüggvény a tartomány x elemeinek számát adja vissza

[ lower_bound(kulcs), upper_bound(kulcs) )

amely térkép esetén 0 vagy 1, ami egy egyedi asszociatív tároló.

példa

Az alábbi példa a tagfüggvény használatát map::count mutatja be.

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

Ellenőrzi, hogy van-e a megadott kulccsal rendelkező elem a map.

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

Paraméterek

K
A kulcs típusa.

key
Az elem keresendő kulcsértéke.

Visszaadott érték

true, hogy az elem megtalálható-e a tárolóban; máskülönben false.

Megjegyzések

contains() a C++20-ban új. A használatához adja meg a /std:c++20 vagy újabb fordító lehetőséget.

template<class K> bool contains(const K& key) const csak akkor vesz részt a túlterhelés feloldásában, ha key_compare transzparens. További információt az asszociatív tárolók heterogén keresésében talál.

példa

// Requires /std:c++20 or later
#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`

Egy fordított térkép első elemével foglalkozó konstans iterátort ad vissza.

const_reverse_iterator crbegin() const;

Visszaadott érték

Konstans fordított kétirányú iterátor, amely egy fordított map elem első elemével foglalkozik, vagy a megfordítatlan elem utolsó elemével foglalkozik map.

Megjegyzések

crbegin fordított map használ, ugyanúgy, mint beginmap.

Az objektum visszatérési crbeginmap értéke nem módosítható

crbegin használható map visszafelé történő iterálásra.

példa

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

Egy konstans iterátort ad vissza, amely a fordított térkép utolsó elemét követő helyet kezeli.

const_reverse_iterator crend() const;

Visszaadott érték

Konstans fordított kétirányú iterátor, amely egy fordított map elem utolsó elemét (a fordított mapelem első elemét megelőző helyet) kezeli.

Megjegyzések

crend fordított térképpel használható, ugyanúgy, mint end egy map.

A crendvisszatérési értékével a map objektum nem módosítható.

crend segítségével tesztelhető, hogy a fordított iterátor elérte-e a mapvégét.

A visszaadott crend értéket nem szabad elhalasztani.

példa

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

Aláírt egész számtípus, amely a térkép elemeinek számát ábrázolja az iterátorok által mutatott elemek közötti tartományban.

typedef allocator_type::difference_type difference_type;

Megjegyzések

Ez difference_type a típus a tároló iterátorain keresztüli kivonáskor vagy növekménykor visszaadott típus. Ez difference_type általában az iterátorok közötti first tartomány elemeinek számának ábrázolására szolgál, és lastmagában foglalja a hivatkozott first elemet, valamint az elemek tartományát az adott elemig, de nem beleértve az általuk lastmutatott elemet.

Bár difference_type minden olyan iterátorhoz elérhető, amely megfelel egy bemeneti iterátor követelményeinek, beleértve a reverzibilis tárolók által támogatott kétirányú iterátorok osztályát, mint például a készlet, az iterátorok közötti kivonást csak véletlenszerű hozzáférési iterátorok támogatják, amelyeket véletlenszerű hozzáférési tárolók, például vektorok biztosítanak.

példa

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

Beszúr egy helyben létrehozott elemet (másolási vagy áthelyezési műveleteket nem hajt végre) a térképen.

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

Paraméterek

args
A leképezésbe beszúrni kívánt elem létrehozásához továbbított argumentumok, kivéve, ha már tartalmaz olyan elemet, amelynek az értéke azonos sorrendben van.

Visszaadott érték

Annak pair az összetevőnek, amelynek bool az true összetevője, ha beszúrás történt, és false ha a térkép már tartalmazott egy azonos értékű elemet a rendezésben. A visszatérési érték pár iterátor-összetevője az újonnan beszúrt elemre mutat, ha az bool összetevő igaz, vagy a meglévő elemre, ha az bool összetevő hamis.

Ha egy adott iterátor összetevőjét pairprszeretné elérni, használja pr.firsta ; a hareferenst, használja a következőt *pr.first: . A bool összetevő eléréséhez használja a pr.second. Példaként tekintse meg a cikk későbbi részében található mintakódot.

Megjegyzések

A függvény nem érvényteleníti az iterátorokat és a hivatkozásokat.

Az áttelepítés során, ha kivételt jelez, a tároló állapota nem módosul.

Egy elem value_type egy pár, így az elem értéke rendezett pár lesz, amelynek első összetevője megegyezik a kulcsértékkel, a második összetevő pedig az elem adatértékével.

példa

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

Beszúr egy helyben létrehozott elemet (nincs másolási vagy áthelyezési művelet), elhelyezési tipptel.

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

Paraméterek

args
A leképezésbe illesztendő elem létrehozásához továbbított argumentumok, kivéve, ha a térkép már tartalmazza ezt az elemet, vagy általánosabban, kivéve, ha már tartalmaz olyan elemet, amelynek a kulcsa azonos sorrendben van rendezve.

where
A megfelelő beszúrási pont keresésének helye. (Ha ez a pont közvetlenül megelőzi a holtpontot, a beszúrás logaritmikus idő helyett amortizált állandó időben fordulhat elő.)

Visszaadott érték

Az újonnan beszúrt elem iterátora.

Ha a beszúrás meghiúsult, mert az elem már létezik, egy iterátort ad vissza a meglévő elemhez a kulccsal.

Megjegyzések

A függvény nem érvényteleníti az iterátorokat és a hivatkozásokat.

Az áttelepítés során, ha kivételt jelez, a tároló állapota nem módosul.

Egy elem value_type egy pár, így az elem értéke rendezett pár lesz, amelynek első összetevője megegyezik a kulcsértékkel, a második összetevő pedig az elem adatértékével.

példa

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

Ellenőrzi, hogy egy térkép üres-e.

bool empty() const;

Visszaadott érték

true ha a térkép üres; false ha a térkép nincs meg.

példa

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

A múlt-the-end iterátort adja vissza.

const_iterator end() const;

iterator end();

Visszaadott érték

A múlt-the-end iterator. Ha a térkép üres, akkor map::end() == map::begin().

Megjegyzések

end annak tesztelésére szolgál, hogy egy iterátor teljesítette-e a térkép végét.

A visszaadott end értéket nem szabad elhalasztani.

Példakód: map::find.

`equal_range`

Egy iterátorpárt ad vissza, amely a lower_bound kulcs és a upper_bound kulcs értékét jelöli.

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

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

Paraméterek

key
Az argumentumkulcs értéke, amelyet össze kell hasonlítani a keresett térkép egyik elemének rendezési kulcsával.

Visszaadott érték

A tagfüggvény által visszaadott pár pr első iterátorának eléréséhez használja pra következőt: . először, majd az alsó határos iterátor elhalasztásához használja a *(.prelső). A tagfüggvény által visszaadott pár pr második iterátorának eléréséhez használja pra következőt: . második, és a felső kötött iterátor elhalasztásához használja a *(.prmásodik).

példa

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

Eltávolít egy elemet vagy elemtartományt a térképen a megadott pozíciókból, vagy eltávolítja a megadott kulcsnak megfelelő elemeket.

iterator erase(
    const_iterator Where);

iterator erase(
    const_iterator First,
    const_iterator Last);

size_type erase(
    const key_type& Key);

Paraméterek

Where
Az eltávolítandó elem pozíciója.

First
Az első eltávolítandó elem pozíciója.

Last
Az utolsó eltávolítandó elemen túli pozíció.

Key
Az eltávolítandó elemek kulcsértéke.

Visszaadott érték

Az első két tagfüggvény esetében egy kétirányú iterátor, amely kijelöli az eltávolított elemeken túl fennmaradó első elemet, vagy egy olyan elemet, amely a térkép vége, ha nincs ilyen elem.

A harmadik tagfüggvény esetében a térképről eltávolított elemek számát adja vissza.

példa

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

Egy olyan iterátort ad vissza, amely egy adott kulccsal egyenértékű kulccsal rendelkező térkép egy elemének helyére hivatkozik.

iterator find(const Key& key);

const_iterator find(const Key& key) const;

Paraméterek

key
A keresendő térkép egyik elemének rendezési kulcsával egyeztetendő kulcsérték.

Visszaadott érték

Egy iterátor, amely egy adott kulccsal rendelkező elem helyére hivatkozik, vagy a (map) utolsó elemének map::end() sikeres helyét, ha nem található egyezés a kulcshoz.

Megjegyzések

A tagfüggvény egy olyan iterátort ad vissza, amely egy map olyan elemre hivatkozik, amelynek rendezési kulcsa megegyezik egy bináris predikátum argumentumkulcsával, amely az összehasonlíthatósági reláción alapuló rendezést indukál.

Ha a visszaadott find érték egy const_iteratoradotthoz van rendelve, a leképezési objektum nem módosítható. Ha a visszaadott find érték egy iteratoradott objektumhoz van rendelve, a leképezési objektum módosítható

példa

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

Visszaadja a térkép létrehozásához használt kiosztó objektum másolatát.

allocator_type get_allocator() const;

Visszaadott érték

A térkép által használt kiosztó.

Megjegyzések

A térképosztály kiosztói határozzák meg, hogy az osztály hogyan kezeli a tárterületet. A C++ standard kódtár-tárolóosztályokhoz megadott alapértelmezett kiosztók elegendőek a legtöbb programozási igényhez. A saját kiosztóosztály írása és használata egy speciális C++ témakör.

példa

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

Elem vagy elemtartomány beszúrása egy térképbe.

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

Paraméterek

Val
A térképbe beszúrni kívánt elem értéke, kivéve, ha már tartalmaz egy olyan elemet, amelynek a kulcsa ezzel egyenértékűen van rendezve.

Where
A megfelelő beszúrási pont keresésének helye. (Ha ez a pont közvetlenül megelőzi Where, a beszúrás a logaritmikus idő helyett amortizált állandó időben fordulhat elő.)

ValTy
Sablonparaméter, amely megadja azt az argumentumtípust, amellyel a leképezés létrehozhat egy elemet value_type, és argumentumként tökéletes továbbítást Val végezhet.

First
Az első másolandó elem pozíciója.

Last
Az utolsó másolandó elemen túli pozíció.

InputIterator
Sablonfüggvény argumentuma, amely megfelel egy bemeneti iterátor követelményeinek, olyan típusú elemekre mutat, amelyek value_type objektumok létrehozásához használhatók.

IList
Az a initializer_list, amelyből az elemeket másolni szeretné.

Visszaadott érték

Az egyelemű tagfüggvények (1) és (2) egy pair olyan összetevőt ad vissza, amelynek bool az összetevője igaz, ha beszúrás történt, és hamis, ha a térkép már tartalmazott egy olyan elemet, amelynek a kulcsa a rendezés során egyenértékű értékkel rendelkezik. A visszatérési érték pár iterátor-összetevője az újonnan beszúrt elemre mutat, ha az bool összetevő igaz, vagy a meglévő elemre, ha az bool összetevő hamis.

Az egyelemes tagfüggvények (3) és (4) egy olyan iterátort ad vissza, amely arra a helyre mutat, ahol az új elemet beszúrták a térképre, vagy ha már létezik egy azonos kulccsal rendelkező elem, a meglévő elemhez.

Megjegyzések

Ez a függvény nem érvényteleníti az iterátorokat, a mutatókat és a hivatkozásokat.

Egyetlen elem beszúrása során, ha kivételt jelez, a tároló állapota nem módosul. Több elem beszúrása során, ha kivétel történik, a tároló meghatározatlan, de érvényes állapotban marad.

Az egyelemes tagfüggvények által visszaadott pairpr iterátor összetevőjének eléréséhez használja a pr.first; A visszaadott páron belüli iterátor elhalasztásához használja a *pr.first, amely egy elemet ad meg. A bool összetevő eléréséhez használja a pr.second. Példaként tekintse meg a cikk későbbi részében található mintakódot.

A tároló value_type a tárolóhoz tartozó típusdef, a térképhez pedig map<K, V>::value_typepair<const K, V>. Az elem értéke egy rendezett pár, amelyben az első összetevő megegyezik a kulcsértékkel, a második összetevő pedig az elem adatértékével.

A tartománytagfüggvény (5) az elemértékek sorozatát egy olyan térképbe szúrja be, amely megfelel a tartomány [First, Last)iterátora által kezelt egyes elemeknek, Last ezért nem lesz beszúrva. A tárolótagfüggvény end() a tároló utolsó eleme utáni pozícióra hivatkozik – például az utasítás m.insert(v.begin(), v.end()); megpróbálja beszúrni v összes elemét a m. A rendszer csak azokat az elemeket szúrja be, amelyek egyedi értékekkel rendelkeznek a tartományban; az ismétlődő elemek figyelmen kívül lesznek hagyva. Az elutasított elemek megfigyeléséhez használja a insertegyelemű verzióit.

Az inicializáló lista tagfüggvénye (6) elemeket initializer_list másol a térképre.

A helyben létrehozott elem beszúrásáról – vagyis másolási vagy áthelyezési műveletek nélkül – lásd: map::emplace és map::emplace_hint.

példa

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

Olyan típus, amely kétirányú iterátort biztosít, amely képes a térkép bármely elemének olvasására vagy módosítására.

typedef implementation-defined iterator;

Megjegyzések

A térkép által definiált iterátor olyan elemekre mutat, amelyek az elem objektumai value_type, azaz típusa pair<const Key, Type>, amelynek első tagja az elem kulcsa, és amelynek második tagja az elem által birtokolt leképezési datum.

Ha egy térkép egy elemére mutató iterátor iterát szeretne elferdíteni, használja az operátort -> .

Az elem kulcsának értékéhez való hozzáféréshez használja Iter->firsta következőt (*Iter).first: . Az elemhez hozzárendelt datum értékének eléréséhez használja Iter->seconda következőt (*Iter).second: .

példa

Lásd például a begin deklarálandó és használható iteratorpéldákat.

`key_comp`

Lekéri a térkép kulcsainak rendeléséhez használt összehasonlító objektum másolatát.

key_compare key_comp() const;

Visszaadott érték

Azt a függvényobjektumot adja vissza, amelyet a térkép az elemeinek rendezéséhez használ.

Megjegyzések

A tárolt objektum határozza meg a tagfüggvényt

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

amely akkor ad vissza true , ha left előző, és nem egyenlő right a rendezési sorrendben.

példa

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

Olyan típus, amely egy függvényobjektumot biztosít, amely két rendezési kulcsot hasonlít össze a két elem relatív sorrendjének meghatározásához a map.

typedef Traits key_compare;

Megjegyzések

key_compare a Traitssablonparaméter szinonimája.

További információkért Traitslásd az Osztály témakörtmap.

példa

Lásd például a key_comp deklarálandó és használható key_comparepéldákat.

`key_type`

A térkép egyes elemeiben tárolt rendezési kulcsot leíró típus.

typedef Key key_type;

Megjegyzések

key_type a Keysablonparaméter szinonimája.

További információkért Keylásd az Osztály témakör Megjegyzések szakaszátmap.

példa

Lásd például a value_type deklarálandó és használható key_typepéldákat.

`lower_bound`

Egy iterátort ad vissza a térkép első eleméhez egy adott kulcs értékével egyenlő vagy annál nagyobb kulcsértékkel.

iterator lower_bound(const Key& key);

const_iterator lower_bound(const Key& key) const;

Paraméterek

key
Az argumentumkulcs értéke, amelyet össze kell hasonlítani a keresett térkép egyik elemének rendezési kulcsával.

Visszaadott érték

Egy iterator vagy const_iterator több, az argumentumkulcsnál egyenlő vagy annál nagyobb kulccsal rendelkező térképen lévő elem helyét, vagy azt a helyet kezeli, amely a kulcs utolsó elemének map sikerességét jelzi, ha nem található egyezés a kulcshoz.

Ha a visszaadott lower_bound érték egy const_iteratoradotthoz van rendelve, a leképezési objektum nem módosítható. Ha a visszaadott lower_bound érték egy iteratoradotthoz van rendelve, a térképobjektum módosítható.

példa

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

Olyan térképet hoz létre, amely üres, vagy egy más térkép egészének vagy egy részének másolata.

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

Paraméterek

Al
A leképezési objektumhoz használandó tárelosztó osztály, amely alapértelmezés szerint a következő.Allocator

Comp
A típus const Traits összehasonlítási függvénye, amely az elemeket mapaz alapértelmezett értékre hash_comparerendezi.

Right
Annak a térképnek a térképe, amelynek a létrehozott készletnek másolatnak kell lennie.

First
A másolandó elemek tartományának első elemének pozíciója.

Last
Az első elem helye a másolandó elemek tartományán túl.

IList
Az a initializer_list, amelyből az elemeket át szeretné másolni.

Megjegyzések

Minden konstruktor olyan allokátorobjektum-típust tárol, amely kezeli a térkép memóriatárolóját, és amely később hívással get_allocatorvisszaadható. Az osztóparamétert gyakran kihagyják az osztálydeklarációkban és az alternatív kiosztók helyettesítésére használt előfeldolgozási makrókban.

Minden konstruktor inicializálja a térképet.

Minden konstruktor egy Tulajdonságok típusú függvényobjektumot tárol, amely a térkép kulcsai közötti sorrend megállapítására szolgál, és amelyet később hívással key_complehet visszaadni.

Az első három konstruktor üres kezdeti térképet ad meg, a második pedig az elemek sorrendjének meghatározásához használandó összehasonlító függvény típusát (Comp), a harmadik pedig a használni kívánt kiosztótípust (Al). A kulcsszavak explicit letiltják az automatikus típuskonverzió bizonyos típusait.

A negyedik konstruktor megadja a térkép Rightmásolatát.

Az ötödik konstruktor a térkép egy példányát adja meg az áthelyezéssel Right.

A 6., a 7. és a 8. konstruktorok egy olyan szerkezetet initializer_list használnak, amelyből kimásolhatja a tagokat.

A következő három konstruktor az osztály [First, Last) és az osztó összehasonlítási függvényének típusának meghatározásában növekvő explicitséggel másolja a térkép tartományátTraits.

példa

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

A térképen tárolt adatokat képviselő típus.

typedef Type mapped_type;

Megjegyzések

A típus mapped_type az osztály Típussablon paraméterének szinonimája.

További információkért Typelásd az Osztály témakörtmap.

példa

Lásd például a value_type deklarálandó és használható mapped_typepéldákat.

`max_size`

A térkép maximális hosszát adja vissza.

size_type max_size() const;

Visszaadott érték

A térkép maximális lehetséges hossza.

példa

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

Egy adott kulcsértékkel rendelkező elemet szúr be egy térképbe.

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

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

Paraméterek

key
A beszúrni kívánt elem kulcsértéke.

Visszaadott érték

Hivatkozás a beszúrt elem adatértékére.

Megjegyzések

Ha az argumentumkulcs értéke nem található, akkor az adattípus alapértelmezett értékével együtt lesz beszúrva.

operator[] elemeket szúrhat be egy térképbe mm[key] = DataValue; használatával, ahol a DataValue az elem mapped_type értéke keykulcsértékkel.

Ha operator[] használ elemek beszúrására, a visszaadott hivatkozás nem jelzi, hogy egy beszúrás módosítja-e a meglévő elemet, vagy újat hoz létre. A tagfüggvények find és insert segítségével megállapíthatja, hogy egy adott kulccsal rendelkező elem már megtalálható-e a beszúrás előtt.

példa

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

A térkép elemeit lecseréli egy másik térkép másolatára.

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

Paraméterek

right
A map a map.

Megjegyzések

A meglévő elemek mapoperator= törlése után másolhatja vagy áthelyezheti a térkép tartalmátright.

példa

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

Olyan típus, amely mutatót ad egy térkép egy eleméhez.

typedef typename allocator_type::pointer pointer;

Megjegyzések

Egy elem értékének módosítására pointer típus használható.

A legtöbb esetben egy iterator térképobjektum elemeinek elérésére van szükség.

rbegin

Egy fordított térkép első elemével foglalkozó iterátort ad vissza.

const_reverse_iterator rbegin() const;

reverse_iterator rbegin();

Visszaadott érték

Fordított kétirányú iterátor, amely egy fordított térkép első elemét kezeli, vagy a fordított térkép utolsó elemét kezeli.

Megjegyzések

rbegin fordított térképet használ, ugyanúgy, mint begin a térképhez.

Ha a visszaadott rbegin érték egy const_reverse_iteratoradotthoz van rendelve, akkor a leképezési objektum nem módosítható. Ha a visszaadott rbegin érték egy reverse_iteratoradotthoz van rendelve, akkor a leképezési objektum módosítható.

rbegin segítségével visszafelé haladhat végig a térképen.

példa

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

Olyan típus, amely egy térképen tárolt elemre mutató hivatkozást tartalmaz.

typedef typename allocator_type::reference reference;

példa

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

Egy olyan iterátort ad vissza, amely a fordított térkép utolsó elemét követő helyet kezeli.

const_reverse_iterator rend() const;

reverse_iterator rend();

Visszaadott érték

Fordított kétirányú iterátor, amely a fordított térkép utolsó elemét (a fordított térkép első elemét megelőző helyet) kezeli.

Megjegyzések

rend fordított térképet használ, ugyanúgy, mint end a térképhez.

Ha a visszaadott rend érték egy const_reverse_iteratoradotthoz van rendelve, akkor a leképezési objektum nem módosítható. Ha a visszaadott rend érték egy reverse_iteratoradotthoz van rendelve, akkor a leképezési objektum módosítható.

rend segítségével tesztelhető, hogy egy fordított iterátor elérte-e a térkép végét.

A visszaadott rend értéket nem szabad elhalasztani.

példa

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

Olyan típus, amely kétirányú iterátort biztosít, amely képes olvasni vagy módosítani egy elemet egy fordított térképen.

typedef std::reverse_iterator<iterator> reverse_iterator;

Megjegyzések

Egy típus reverse_iterator nem tudja módosítani egy elem értékét, és a térképen fordított módon történő iterálásra szolgál.

A reverse_iterator leképezés által definiált elemek olyan elemekre mutatnak, amelyek olyan típusú objektumok value_type, pair<const Key, Type>amelyeknek az első tagja az elem kulcsa, a második tag pedig az elem által birtokolt leképezési datum.

Ha egy térkép egy elemére mutató reverse_iterator szeretne elferdíteni, használja az operátort->.

Az elem kulcsértékének eléréséhez használja rIter a ->first parancsot, amely egyenértékű a (* rIter) értékkel. először. Az elemhez hozzárendelt datum értékének eléréséhez használja rIter a ->second értéket, amely egyenértékű a (* rIter) értékkel. először.

példa

Lásd például a rbegin deklarálandó és használható reverse_iteratorpéldákat.

`size`

A mapelemeinek számát adja vissza.

size_type size() const;

Visszaadott érték

A térkép aktuális hossza.

példa

Az alábbi példa a tagfüggvény használatát map::size mutatja be.

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

Egy aláíratlan egész számtípus, amely a térkép elemeinek számát jelölheti.

typedef typename allocator_type::size_type size_type;

példa

A deklarálásához és használatához sizelásd a példátsize_type.

elcserél

Két térkép elemeit cseréli le.

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

Paraméterek

right
Az argumentumtérkép, amely a felcserélni kívánt elemeket tartalmazza a céltérképpel.

Megjegyzések

A tagfüggvény érvényteleníti azokat a hivatkozásokat, mutatókat és iterátorokat, amelyek a két térkép azon elemeit jelölik ki, amelyek elemeit kicserélik.

példa

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

Egy iterátort ad vissza a térkép első eleméhez, amely egy adott kulcs értékénél nagyobb értékkel rendelkezik.

iterator upper_bound(const Key& key);

const_iterator upper_bound(const Key& key) const;

Paraméterek

key
Az argumentumkulcs értéke, amelyet össze kell hasonlítani a keresett térkép egyik elemének rendezési kulcsértékével.

Visszaadott érték

Egy iterator vagy const_iterator több, az argumentumkulcsnál nagyobb kulccsal rendelkező, vagy az argumentumkulcsnál nagyobb kulccsal rendelkező elem helyével foglalkozik, ha nem található egyezés a kulcs utolsó elemével map .

Ha a visszatérési érték egy const_iteratoradotthoz van rendelve, a leképezési objektum nem módosítható. Ha a visszatérési érték hozzá van rendelve egyhez iterator, a leképezési objektum módosítható.

példa

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

A tagfüggvény visszaad egy függvényobjektumot, amely a kulcsértékek összehasonlításával határozza meg a térkép elemeinek sorrendjét.

value_compare value_comp() const;

Visszaadott érték

Azt az összehasonlító függvényobjektumot adja vissza, amelyet a térkép az elemek rendezéséhez használ.

Megjegyzések

M térkép esetén, ha két e1(k1, d1) és e2(k2, d2) elem olyan típusú objektum, ahol value_type és a k1 a típuskulcsa, a key_type és a d2 pedig a típusuk, akkor mapped_type az egyenértékű.m.value_comp(e1, e2)m.key_comp(k1, k2) Egy tárolt objektum határozza meg a tagfüggvényt

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

amely akkor ad true vissza, ha az előző kulcsértéke left nem egyenlő a rendezési sorrend kulcsértékével right .

példa

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

A térképen elemként tárolt objektum típusa.

typedef pair<const Key, Type> value_type;

példa

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

Lásd még

Konténerek
Szálbiztonság a C++ Standard könyvtárban
Standard C++ kódtár-referenciák

Visszacsatolás

Hasznos volt ez az oldal?

Last updated on 2025-11-07

Megosztás:

map osztály

Szemantika

Paraméterek

Megjegyzések

Tagok

Konstruktorok

Typedefs

Tagfüggvények

Működtetők

allocator_type

példa

at

Paraméterek

Visszaadott érték

Megjegyzések

példa

begin

Visszaadott érték

példa

cbegin

Visszaadott érték

Megjegyzések

cend

Visszaadott érték

Megjegyzések

clear

példa

const_iterator

Megjegyzések

példa

const_pointer

Megjegyzések

const_reference

példa

const_reverse_iterator

Megjegyzések

példa

count

Paraméterek

Visszaadott érték

Megjegyzések

példa

contains

Paraméterek

Visszaadott érték

Megjegyzések

példa

crbegin

Visszaadott érték

Megjegyzések

példa

crend

Visszaadott érték

Megjegyzések

példa

difference_type

Megjegyzések

példa

emplace

Paraméterek

Visszaadott érték

Megjegyzések

példa

emplace_hint

Paraméterek

Visszaadott érték

Megjegyzések

példa

empty

Visszaadott érték

példa

end

Visszaadott érték

Megjegyzések

equal_range

Paraméterek

Visszaadott érték

példa

erase

`map` osztály

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