map-klass

Används för lagring och hämtning av data från en samling där varje element är ett par som har både ett datavärde och en sorteringsnyckel. Värdet för nyckeln är unikt och används för att automatiskt sortera data.

Värdet för ett element i en karta kan ändras direkt. Nyckelvärdet är en konstant och kan inte ändras. I stället måste nyckelvärden som är associerade med gamla element tas bort och nya nyckelvärden måste infogas för nya element.

Syntax

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

Parameterar

Key
Den nyckeldatatyp som ska lagras i map.

Type
Den elementdatatyp som ska lagras i map.

Traits
Den typ som tillhandahåller ett funktionsobjekt som kan jämföra två elementvärden som sorteringsnycklar för att fastställa deras relativa ordning i map. Det här argumentet är valfritt och det binära predikatet less<Key> är standardvärdet.

I C++14 kan du aktivera heterogen sökning genom att ange predikatet std::less<> som inte har några typparametrar. Mer information finns i Heterogen sökning i associativa containrar .

Allocator
Den typ som representerar det lagrade allokeringsobjektet som kapslar in information om kartans allokering och frigöring av minne. Det här argumentet är valfritt och standardvärdet är allocator<pair<const Key, Type> >.

Anmärkningar

Mappningsklassen C++ StandardBibliotek är:

• En container med variabel storlek som effektivt hämtar elementvärden baserat på associerade nyckelvärden.

• Reversibel eftersom det ger dubbelriktade iteratorer för åtkomst till dess element.

• Sorterade eftersom dess element sorteras efter nyckelvärden enligt en angiven jämförelsefunktion.

• Unik. eftersom vart och ett av dess element måste ha en unik nyckel.

• En par-associativ container eftersom dess elementdatavärden skiljer sig från dess nyckelvärden.

• En klassmall eftersom den funktionalitet som den tillhandahåller är allmän och oberoende av element- eller nyckeltyp. De datatyper som används för element och nycklar anges som parametrar i klassmallen tillsammans med jämförelsefunktionen och allokeraren.

Iteratorn som tillhandahålls av kartklassen är en dubbelriktad iterator, men klassmedlemsfunktionerna insert och map har versioner som tar som mallparametrar en svagare indata-iterator, vars funktionskrav är färre än de som garanteras av klassen med dubbelriktade iteratorer. De olika iteratorbegreppen är relaterade till förbättringar i deras funktioner. Varje iteratorkoncept har en egen uppsättning krav, och de algoritmer som fungerar med det måste begränsas av dessa krav. En iterator för indata kan derefereras för att referera till ett objekt och kan ökas till nästa iterator i sekvensen.

Vi rekommenderar att du baserar valet av containertyp på den typ av sökning och infogning som krävs av programmet. Associativa containrar är optimerade för åtgärder för sökning, infogning och borttagning. De medlemsfunktioner som uttryckligen stöder dessa åtgärder gör dem i värsta fall som är proportionella mot logaritmen för antalet element i containern. Om element infogas ogiltigförklaras inga iteratorer och om element tas bort ogiltigförklaras endast de iteratorer som specifikt pekar på de borttagna elementen.

Vi rekommenderar att du gör kartan till valfri associativ container när villkor som associerar värden med nycklar uppfylls av programmet. En modell för den här typen av struktur är en ordnad lista med unikt förekommande nyckelord som har associerade strängvärden som tillhandahåller definitioner. Om ett ord har mer än en korrekt definition, så att nyckeln inte är unik, skulle en multimapp vara den container som väljs. Om bara listan med ord lagras är en uppsättning lämplig container. Om flera förekomster av orden tillåts är en flermängd lämplig.

Kartan beställer de element som den styr genom att anropa ett lagrat funktionsobjekt av typen key_compare. Det här lagrade objektet är en jämförelsefunktion som nås genom att anropa key_comp metoden. I allmänhet jämförs två givna element för att avgöra om det ena är mindre än det andra eller om de är likvärdiga. När alla element jämförs skapas en ordnad sekvens med icke-likvärdiga element.

Medlemmar

Konstruktörer

Typedefs

Medlemsfunktioner

Operatörer

allocator_type

En typ som representerar allokeringsklassen för kartobjektet.

typedef Allocator allocator_type;

Exempel

Se exempel för get_allocator ett exempel som använder allocator_type.

at

Söker efter ett element med ett angivet nyckelvärde.

Type& at(const Key& key);

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

Parameterar

key
Nyckelvärdet som ska hittas.

Returvärde

En referens till datavärdet för elementet som hittades.

Anmärkningar

Om argumentnyckelvärdet inte hittas utlöser funktionen ett objekt av klassklassout_of_range.

Exempel

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

Returnerar en iterator som adresserar det första elementet i map.

const_iterator begin() const;

iterator begin();

Returvärde

En dubbelriktad iterator som adresserar det första elementet på map eller platsen som lyckas med en tom karta.

Exempel

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

Returnerar en const iterator som adresserar platsen precis utanför det sista elementet i ett intervall.

const_iterator cbegin() const;

Returvärde

En const dubbelriktad iterator som adresserar det första elementet i intervallet, eller platsen precis utanför slutet av ett tomt intervall (för ett tomt intervall, cbegin() == cend()).

Anmärkningar

Med returvärdet för cbeginkan elementen i intervallet inte ändras.

Du kan använda den här medlemsfunktionen i stället för funktionen begin() medlem för att garantera att returvärdet är const_iterator. Vanligtvis används det tillsammans med nyckelordet auto typavdrag, som du ser i följande exempel. I exemplet bör du överväga att Container vara en ändringsbar (icke-const) container av något slag som stöder begin() och cbegin().

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

// i2 is Container<T>::const_iterator

cend

Returnerar en const iterator som adresserar platsen precis utanför det sista elementet i ett intervall.

const_iterator cend() const;

Returvärde

En const iterator med dubbelriktad åtkomst som pekar precis utanför intervallets slut.

Anmärkningar

cend används för att testa om en iterator har passerat slutet av sitt intervall.

Du kan använda den här medlemsfunktionen i stället för funktionen end() medlem för att garantera att returvärdet är const_iterator. Vanligtvis används det tillsammans med nyckelordet auto typavdrag, som du ser i följande exempel. I exemplet bör du överväga att Container vara en ändringsbar (icke-const) container av något slag som stöder end() och cend().

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

// i2 is Container<T>::const_iterator

Värdet som returneras av cend bör inte derefereras.

clear

Raderar alla element i en karta.

void clear();

Exempel

I följande exempel visas användningen av map::clear medlemsfunktionen.

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

En typ som tillhandahåller en dubbelriktad iterator som kan läsa ett const element i map.

typedef implementation-defined const_iterator;

Anmärkningar

En typ const_iterator kan inte användas för att ändra värdet för ett element.

Definierad const_iterator av mappning pekar på element som är objekt av value_type, som är av typen pair<constKey, Type>, vars första medlem är nyckeln till elementet och vars andra medlem är det mappade datum som innehas av elementet.

Om du vill avreferering av en const_iteratorcIter pekar på ett element i en karta använder du operatorn -> .

Om du vill komma åt värdet för nyckeln för elementet använder du cIter ->first, vilket motsvarar (* cIter). first.

Om du vill komma åt värdet för det mappade datumet för elementet använder du cIter ->second, vilket motsvarar (* cIter). second.

Exempel

Se exempel för begin ett exempel som använder const_iterator.

const_pointer

En typ som ger en pekare till ett const element på en karta.

typedef typename allocator_type::const_pointer const_pointer;

Anmärkningar

En typ const_pointer kan inte användas för att ändra värdet för ett element.

I de flesta fall bör en iterator användas för att komma åt elementen i ett kartobjekt.

const_reference

En typ som ger en referens till ett const element som lagras på en karta för att läsa och utföra const åtgärder.

typedef typename allocator_type::const_reference const_reference;

Exempel

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

En typ som tillhandahåller en dubbelriktad iterator som kan läsa alla const element i map.

typedef std::reverse_iterator<const_iterator> const_reverse_iterator;

Anmärkningar

En typ const_reverse_iterator kan inte ändra värdet för ett element och används för att iterera genom kartan i omvänd ordning.

Definierad const_reverse_iterator av mappning pekar på element som är objekt av value_type, som är av typen pair<const Key, Type>, vars första medlem är nyckeln till elementet och vars andra medlem är det mappade datum som innehas av elementet.

Om du vill avreferering av en const_reverse_iterator crIter pekar på ett element i en karta använder du operatorn -> .

Om du vill komma åt värdet för nyckeln för elementet använder du crIter ->first, vilket motsvarar (* crIter).first.

Om du vill komma åt värdet för det mappade datumet för elementet använder du crIter ->second, vilket motsvarar (* crIter).first.

Exempel

Se exemplet för rend ett exempel på hur du deklarerar och använder const_reverse_iterator.

count

Returnerar antalet element i en karta vars nyckel matchar en parameter angiven nyckel.

size_type count(const Key& key) const;

Parameterar

key
Nyckelvärdet för de element som ska matchas från kartan.

Returvärde

1 om kartan innehåller ett element vars sorteringsnyckel matchar parameternyckeln. 0 om kartan inte innehåller ett element med en matchande nyckel.

Anmärkningar

Medlemsfunktionen returnerar antalet element x i intervallet

[ lower_bound(nyckel), upper_bound(nyckel) )

som är 0 eller 1 när det gäller karta, vilket är en unik associativ container.

Exempel

I följande exempel visas användningen av map::count medlemsfunktionen.

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

Kontrollerar om det finns ett element med den angivna nyckeln i map.

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

Parameterar

K
Typ av nyckel.

key
Elementets nyckelvärde att söka efter.

Returvärde

true om elementet finns i containern. false annars.

Anmärkningar

contains() är nytt i C++20. Om du vill använda den anger du alternativet /std:c++20 eller senare kompilator.

template<class K> bool contains(const K& key) const deltar endast i överbelastningsmatchning om key_compare är transparent. Mer information finns i Heterogen sökning i associativa containrar .

Exempel

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

Returnerar en const iterator som adresserar det första elementet i en omvänd karta.

const_reverse_iterator crbegin() const;

Returvärde

En omvänd dubbelriktad iterator som hanterar det första elementet i en omvänd map eller adresserar vad som hade varit det sista elementet i det oreverserade map.

Anmärkningar

crbegin används med omvända map precis som begin används med en map.

Med returvärdet crbeginmap kan objektet inte ändras

crbegin kan användas för att iterera genom en map bakåt.

Exempel

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

Returnerar en const-iterator som adresserar platsen som lyckades med det sista elementet i en omvänd karta.

const_reverse_iterator crend() const;

Returvärde

En omvänd dubbelriktad iterator som adresserar platsen som lyckades med det sista elementet i en omvänd map (platsen som hade föregått det första elementet i det oreverserade map).

Anmärkningar

crend används med en omvänd karta precis som end används med en map.

Med returvärdet för crendkan map-objektet inte ändras.

crend kan användas för att testa om en omvänd iterator har nått slutet av sin map.

Värdet som returneras av crend bör inte derefereras.

Exempel

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

En signerad heltalstyp som kan användas för att representera antalet element i en karta i ett intervall mellan element som iteratorer pekar på.

typedef allocator_type::difference_type difference_type;

Anmärkningar

difference_type är den typ som returneras när du subtraherar eller ökar genom iteratorer i containern. difference_type Används vanligtvis för att representera antalet element i intervallet [ första, sista) mellan iteratorerna och first, innehåller elementet som pekas på av last och intervallet av element upp till, men inte inklusive, elementet som pekas first på av last.

Även om difference_type det är tillgängligt för alla iteratorer som uppfyller kraven för en indata iterator, vilket inkluderar klassen av dubbelriktade iteratorer som stöds av reversibla containrar som set, stöds subtraktion mellan iteratorer endast av slumpmässiga åtkomst iteratorer som tillhandahålls av en slumpmässig åtkomstcontainer, till exempel vektor.

Exempel

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

Infogar ett element som konstruerats på plats (inga kopierings- eller flyttåtgärder utförs) i en karta.

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

Parameterar

args
Argumenten vidarebefordrades för att konstruera ett element som ska infogas i kartan om det inte redan innehåller ett element vars värde är ordnat på motsvarande sätt.

Returvärde

En pair vars bool komponent är true om en infogning har gjorts och false om kartan redan innehåller ett element med motsvarande värde i ordningen. Iteratorkomponenten i retur/värde-paret pekar på det nyligen infogade elementet om komponenten bool är sann eller till det befintliga elementet om komponenten bool är false.

Om du vill komma åt iteratorkomponenten i en pairpranvänder pr.firstdu ; för att avreferering av den, använder du *pr.first. Om du vill komma åt komponenten bool använder du pr.second. Ett exempel finns i exempelkoden senare i den här artikeln.

Anmärkningar

Inga iteratorer eller referenser har ogiltigförklarats av den här funktionen.

Om ett undantag utlöses under emplacement ändras inte containerns tillstånd.

value_type för ett element är ett par, så att värdet för ett element blir ett ordnat par med den första komponenten lika med nyckelvärdet och den andra komponenten som är lika med elementets datavärde.

Exempel

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

Infogar ett element som är konstruerat på plats (inga kopierings- eller flyttåtgärder utförs) med ett placeringstips.

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

Parameterar

args
Argumenten som vidarebefordras för att konstruera ett element som ska infogas på kartan om inte kartan redan innehåller elementet eller, mer allmänt, om det inte redan innehåller ett element vars nyckel är ordnad på motsvarande sätt.

where
Platsen där du vill börja söka efter rätt insättningspunkt. (Om den punkten omedelbart föregår där kan infogning ske i amorterad konstant tid i stället för logaritmisk tid.)

Returvärde

En iterator till det nyligen infogade elementet.

Om infogningen misslyckades eftersom elementet redan finns returnerar en iterator till det befintliga elementet med dess nyckel.

Anmärkningar

Inga iteratorer eller referenser har ogiltigförklarats av den här funktionen.

Om ett undantag utlöses under emplacement ändras inte containerns tillstånd.

value_type för ett element är ett par, så att värdet för ett element blir ett ordnat par med den första komponenten lika med nyckelvärdet och den andra komponenten som är lika med elementets datavärde.

Exempel

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

Testar om en karta är tom.

bool empty() const;

Returvärde

true om kartan är tom; false om kartan inte är snål.

Exempel

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

Returnerar iteratorn past-the-end.

const_iterator end() const;

iterator end();

Returvärde

Iteratorn past-the-end. Om kartan är tom, så map::end() == map::begin().

Anmärkningar

end används för att testa om en iterator har passerat slutet av kartan.

Värdet som returneras av end bör inte derefereras.

Ett kodexempel finns i map::find.

equal_range

Returnerar ett par iteratorer som representerar lower_bound nyckeln och upper_bound nyckelns.

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

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

Parameterar

key
Det argumentnyckelvärde som ska jämföras med sorteringsnyckeln för ett element från kartan som genomsöks.

Returvärde

Om du vill komma åt den första iteratorn för ett par pr som returneras av medlemsfunktionen använder du pr. först, och om du vill avreferering av iteratorn med lägre gräns använder du *(pr. först). Om du vill komma åt den andra iteratorn för ett par pr som returneras av medlemsfunktionen använder du pr. second och för att avreferering av den övre bundna iteratorn använder du *(pr. andra).

Exempel

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

Tar bort ett element eller ett område med element i en karta från angivna positioner eller tar bort element som matchar en angiven nyckel.

iterator erase(
    const_iterator Where);

iterator erase(
    const_iterator First,
    const_iterator Last);

size_type erase(
    const key_type& Key);

Parameterar

Where
Positionen för elementet som ska tas bort.

First
Positionen för det första elementet som ska tas bort.

Last
Placera precis utanför det sista elementet som ska tas bort.

Key
Nyckelvärdet för de element som ska tas bort.

Returvärde

För de två första medlemsfunktionerna, en dubbelriktad iterator som anger det första elementet som återstår utöver alla element som tas bort, eller ett element som är slutet på kartan om det inte finns något sådant element.

För den tredje medlemsfunktionen returnerar antalet element som har tagits bort från kartan.

Exempel

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

Returnerar en iterator som refererar till platsen för ett element i en karta som har en nyckel som motsvarar en angiven nyckel.

iterator find(const Key& key);

const_iterator find(const Key& key) const;

Parameterar

key
Nyckelvärdet som ska matchas av sorteringsnyckeln för ett element från kartan som genomsöks.

Returvärde

En iterator som refererar till platsen för ett element med en angiven nyckel eller platsen som lyckas med det sista elementet i map (map::end()) om ingen matchning hittas för nyckeln.

Anmärkningar

Medlemsfunktionen returnerar en iterator som refererar till ett element i map vars sorteringsnyckel motsvarar argumentnyckeln under ett binärt predikat som inducerar en ordning baserat på en relation som är mindre än jämförbar.

Om returvärdet find för har tilldelats till ett const_iteratorgår det inte att ändra mappningsobjektet. Om returvärdet find för har tilldelats till ett iteratorkan mappningsobjektet ändras

Exempel

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

Returnerar en kopia av allokeringsobjektet som används för att konstruera kartan.

allocator_type get_allocator() const;

Returvärde

Allokeraren som används av kartan.

Anmärkningar

Allokerare för kartklassen anger hur klassen hanterar lagring. Standardallokeringsprogrammen som levereras med C++ Standard Library-containerklasser räcker för de flesta programmeringsbehov. Att skriva och använda din egen allokeringsklass är ett avancerat C++-ämne.

Exempel

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

Infogar ett element eller ett område med element i en karta.

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

Parameterar

Val
Värdet för ett element som ska infogas i kartan om det inte redan innehåller ett element vars nyckel är ordnad på motsvarande sätt.

Where
Platsen där du vill börja söka efter rätt insättningspunkt. (Om den punkten omedelbart föregår Wherekan infogning ske i amorterad konstant tid i stället för logaritmisk tid.)

ValTy
Mallparameter som anger den argumenttyp som kartan kan använda för att konstruera ett element av value_type, och perfekt vidarebefordran Val som ett argument.

First
Positionen för det första element som ska kopieras.

Last
Positionen precis utanför det sista element som ska kopieras.

InputIterator
Mallfunktionsargument som uppfyller kraven för en indata iterator som pekar på element av en typ som kan användas för att konstruera value_type objekt.

IList
Den initializer_list som elementen ska kopieras från.

Returvärde

Medlemsfunktionerna med ett element, (1) och (2), returnerar en pair vars bool komponent är sann om en insättning gjordes och falskt om kartan redan innehåller ett element vars nyckel hade ett motsvarande värde i ordningen. Iteratorkomponenten i retur/värde-paret pekar på det nyligen infogade elementet om komponenten bool är sann eller till det befintliga elementet om komponenten bool är false.

Medlemsfunktionerna single-element-with-hint, (3) och (4), returnerar en iterator som pekar på positionen där det nya elementet infogades på kartan eller, om det redan finns ett element med motsvarande nyckel, till det befintliga elementet.

Anmärkningar

Inga iteratorer, pekare eller referenser har ogiltigförklarats av den här funktionen.

Om ett undantag utlöses under infogningen av bara ett element ändras inte containerns tillstånd. Om ett undantag utlöses under införandet av flera element lämnas containern i ett ospecificerat men giltigt tillstånd.

Om du vill komma åt iteratorkomponenten i en pairpr som returneras av medlemsfunktionerna med ett element använder du pr.first; om du vill avrefereras iteratorn i det returnerade paret använder du *pr.first, vilket ger dig ett element. Om du vill komma åt komponenten bool använder du pr.second. Ett exempel finns i exempelkoden senare i den här artikeln.

value_type för en container är en typedef som tillhör containern, och för mappning är map<K, V>::value_typepair<const K, V>. Värdet för ett element är ett ordnat par där den första komponenten är lika med nyckelvärdet och den andra komponenten är lika med elementets datavärde.

Funktionen range member (5) infogar sekvensen med elementvärden i en karta som motsvarar varje element som hanteras av en iterator i intervallet [First, Last). Därför Last infogas inte. Funktionen containermedlem end() refererar till positionen strax efter det sista elementet i containern– till exempel försöker instruktionen m.insert(v.begin(), v.end()); infoga alla element i v i m. Endast element som har unika värden i intervallet infogas. dubbletter ignoreras. Om du vill se vilka element som avvisas använder du enelementsversionerna av insert.

Medlemsfunktionen i initieringslistan (6) använder en initializer_list för att kopiera element till kartan.

För infogning av ett element som konstruerats på plats, dvs. inga kopierings- eller flyttåtgärder utförs, se map::emplace och map::emplace_hint.

Exempel

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

En typ som tillhandahåller en dubbelriktad iterator som kan läsa eller ändra alla element på en karta.

typedef implementation-defined iterator;

Anmärkningar

Iteratorn som definieras av mappning pekar på element som är objekt av , som är av value_typetypen pair<const Key, Type>, vars första medlem är nyckeln till elementet och vars andra medlem är det mappade datum som innehas av elementet.

Om du vill avreferering av en iterator iter som pekar på ett element i en karta använder du operatorn -> .

Om du vill komma åt värdet för -nyckeln för elementet använder du Iter->first, vilket motsvarar (*Iter).first. Om du vill komma åt värdet för det mappade datumet för elementet använder du Iter->second, vilket motsvarar (*Iter).second.

Exempel

Se exempel för begin ett exempel på hur du deklarerar och använder iterator.

key_comp

Hämtar en kopia av jämförelseobjektet som används för att beställa nycklar i en karta.

key_compare key_comp() const;

Returvärde

Returnerar funktionsobjektet som en karta använder för att ordna dess element.

Anmärkningar

Det lagrade objektet definierar medlemsfunktionen

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

som returnerar true om left föregår och inte är lika med right i sorteringsordningen.

Exempel

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

En typ som tillhandahåller ett funktionsobjekt som kan jämföra två sorteringsnycklar för att fastställa den relativa ordningen för två element i map.

typedef Traits key_compare;

Anmärkningar

key_compare är synonymt med mallparametern Traits.

Mer information om Traitsfinns i map avsnittet Klass .

Exempel

Se exempel för key_comp ett exempel på hur du deklarerar och använder key_compare.

key_type

En typ som beskriver sorteringsnyckeln som lagras i varje element på kartan.

typedef Key key_type;

Anmärkningar

key_type är synonymt med mallparametern Key.

Mer information om Keyfinns i avsnittet Kommentarer i map ämnet Klass .

Exempel

Se exempel för value_type ett exempel på hur du deklarerar och använder key_type.

lower_bound

Returnerar en iterator till det första elementet i en karta med ett nyckelvärde som är lika med eller större än för en angiven nyckel.

iterator lower_bound(const Key& key);

const_iterator lower_bound(const Key& key) const;

Parameterar

key
Det argumentnyckelvärde som ska jämföras med sorteringsnyckeln för ett element från kartan som genomsöks.

Returvärde

En iterator eller const_iterator som adresserar platsen för ett element i en karta som med en nyckel som är lika med eller större än argumentnyckeln, eller som adresserar platsen som lyckas med det sista elementet i map om ingen matchning hittas för nyckeln.

Om returvärdet lower_bound för har tilldelats till ett const_iteratorgår det inte att ändra mappningsobjektet. Om returvärdet lower_bound för har tilldelats till ett iteratorkan mappningsobjektet ändras.

Exempel

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

Konstruerar en karta som är tom eller som är en kopia av hela eller en del av någon annan karta.

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

Parameterar

Al
Den lagringsallokeringsklass som ska användas för det här kartobjektet, som standard är Allocator.

Comp
Jämförelsefunktionen av typen const Traits som används för att sortera elementen mapi , som standard är hash_compare.

Right
Kartan som den konstruerade uppsättningen ska vara en kopia av.

First
Positionen för det första elementet i området med element som ska kopieras.

Last
Positionen för det första elementet utöver det område av element som ska kopieras.

IList
Den initializer_list som elementen ska kopieras från.

Anmärkningar

Alla konstruktorer lagrar en typ av allokeringsobjekt som hanterar minneslagring för kartan och som senare kan returneras genom att anropa get_allocator. Allokeringsparametern utelämnas ofta i klassdeklarationerna och förbearbetar makron som används för att ersätta alternativa allokerare.

Alla konstruktorer initierar sin karta.

Alla konstruktorer lagrar ett funktionsobjekt av typen Egenskaper som används för att upprätta en ordning bland kartans nycklar och som senare kan returneras genom att anropa key_comp.

De första tre konstruktorerna anger en tom inledande karta, den andra anger vilken typ av jämförelsefunktion (Comp) som ska användas för att fastställa ordningen på elementen och den tredje anger uttryckligen den allokeringstyp (Al) som ska användas. explicit Nyckelordet undertrycker vissa typer av automatisk typkonvertering.

Den fjärde konstruktorn anger en kopia av kartan Right.

Den femte konstruktorn anger en kopia av kartan genom att flytta Right.

Konstruktorerna 6, 7 och 8 använder en initializer_list från vilken medlemmarna ska kopieras.

De kommande tre konstruktorerna kopierar intervallet [First, Last) för en karta med ökad explicititet i att ange typen av jämförelsefunktion för klass Traits och allokering.

Exempel

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

En typ som representerar data som lagras på en karta.

typedef Type mapped_type;

Anmärkningar

Typen mapped_type är en synonym för klassens typmallsparameter.

Mer information om Typefinns i map avsnittet Klass .

Exempel

Se exempel för value_type ett exempel på hur du deklarerar och använder mapped_type.

max_size

Returnerar kartans maximala längd.

size_type max_size() const;

Returvärde

Den maximala möjliga längden på kartan.

Exempel

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

Infogar ett element i en karta med ett angivet nyckelvärde.

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

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

Parameterar

key
Nyckelvärdet för det element som ska infogas.

Returvärde

En referens till datavärdet för det infogade elementet.

Anmärkningar

Om argumentnyckelvärdet inte hittas infogas det tillsammans med standardvärdet för datatypen.

operator[] kan användas för att infoga element i en karta m med hjälp av m[key] = DataValue; där DataValue är värdet för elementets mapped_type med nyckelvärdet key.

När du använder operator[] för att infoga element anger den returnerade referensen inte om en infogning ändrar ett befintligt element eller skapar ett nytt. Medlemsfunktionerna find och insert kan användas för att avgöra om ett element med en angiven nyckel redan finns före en infogning.

Exempel

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

Ersätter elementen i en karta med en kopia av en annan karta.

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

Parameterar

right
Den map som kopieras till map.

Anmärkningar

När du har raderat befintliga element i en mapkopierar operator= eller flyttar du innehållet right i till kartan.

Exempel

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

En typ som ger en pekare till ett element i en karta.

typedef typename allocator_type::pointer pointer;

Anmärkningar

En typ pointer kan användas för att ändra värdet för ett element.

I de flesta fall bör en iterator användas för att komma åt elementen i ett kartobjekt.

rbegin

Returnerar en iterator som adresserar det första elementet i en omvänd karta.

const_reverse_iterator rbegin() const;

reverse_iterator rbegin();

Returvärde

En omvänd dubbelriktad iterator som adresserar det första elementet i en omvänd karta eller som tar upp vad som var det sista elementet på den oreverserade kartan.

Anmärkningar

rbegin används med en omvänd karta precis som begin används med en karta.

Om returvärdet rbegin för har tilldelats till ett const_reverse_iteratorgår det inte att ändra mappningsobjektet. Om returvärdet rbegin för har tilldelats till ett reverse_iteratorkan mappningsobjektet ändras.

rbegin kan användas för att iterera genom en karta bakåt.

Exempel

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

En typ som ger en referens till ett element som lagras på en karta.

typedef typename allocator_type::reference reference;

Exempel

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

Returnerar en iterator som adresserar platsen som lyckas med det sista elementet i en omvänd karta.

const_reverse_iterator rend() const;

reverse_iterator rend();

Returvärde

En omvänd dubbelriktad iterator som adresserar platsen som lyckades med det sista elementet i en omvänd karta (platsen som hade föregått det första elementet på den oriktade kartan).

Anmärkningar

rend används med en omvänd karta precis som end används med en karta.

Om returvärdet rend för har tilldelats till ett const_reverse_iteratorgår det inte att ändra mappningsobjektet. Om returvärdet rend för har tilldelats till ett reverse_iteratorkan mappningsobjektet ändras.

rend kan användas för att testa om en omvänd iterator har nått slutet av kartan.

Värdet som returneras av rend bör inte derefereras.

Exempel

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

En typ som tillhandahåller en dubbelriktad iterator som kan läsa eller ändra ett element i en omvänd karta.

typedef std::reverse_iterator<iterator> reverse_iterator;

Anmärkningar

En typ reverse_iterator kan inte ändra värdet för ett element och används för att iterera genom kartan i omvänd ordning.

Definierad reverse_iterator av mappning pekar på element som är objekt av value_type, som är av typen pair<const Key, Type>, vars första medlem är nyckeln till elementet och vars andra medlem är det mappade datum som innehas av elementet.

Om du vill avreferering av en reverse_iteratorrIter som pekar på ett element i en karta använder du operatorn -> .

Om du vill komma åt värdet för nyckeln för elementet använder du rIter ->first, vilket motsvarar (* rIter). först. Om du vill komma åt värdet för det mappade datumet för elementet använder du rIter ->second, vilket motsvarar (* rIter). först.

Exempel

Se exempel för rbegin ett exempel på hur du deklarerar och använder reverse_iterator.

size

Returnerar antalet element i map.

size_type size() const;

Returvärde

Kartans aktuella längd.

Exempel

I följande exempel visas användningen av map::size medlemsfunktionen.

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

En osignerad heltalstyp som kan representera antalet element i en karta.

typedef typename allocator_type::size_type size_type;

Exempel

Se exemplet för size ett exempel på hur du deklarerar och använder size_type.

byta

Utbyter elementen i två kartor.

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

Parameterar

right
Argumentkartan som tillhandahåller de element som ska växlas med målkartan.

Anmärkningar

Medlemsfunktionen ogiltigförklarar inga referenser, pekare eller iteratorer som anger element i de två kartor vars element utbyts.

Exempel

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

Returnerar en iterator till det första elementet i en karta som med en nyckel som har ett värde som är större än värdet för en angiven nyckel.

iterator upper_bound(const Key& key);

const_iterator upper_bound(const Key& key) const;

Parameterar

key
Det argumentnyckelvärde som ska jämföras med sorteringsnyckelvärdet för ett element från kartan som genomsöks.

Returvärde

En iterator eller const_iterator som adresserar platsen för ett element i en karta som med en nyckel som är större än argumentnyckeln, eller som adresserar platsen som lyckas med det sista elementet i map om ingen matchning hittas för nyckeln.

Om returvärdet har tilldelats till ett const_iteratorgår det inte att ändra mappningsobjektet. Om returvärdet har tilldelats till ett iteratorkan mappningsobjektet ändras.

Exempel

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

Medlemsfunktionen returnerar ett funktionsobjekt som avgör ordningen på element i en karta genom att jämföra deras nyckelvärden.

value_compare value_comp() const;

Returvärde

Returnerar jämförelsefunktionsobjektet som en karta använder för att ordna dess element.

Anmärkningar

För en karta m, om två element e1(k1, d1) och e2(k2, d2) är objekt av typen value_type, där k1 och k1 är deras nycklar av typen key_type och d1 och d2 är deras data av typen mapped_type, m.value_comp(e1, e2) så motsvarar m.key_comp(k1, k2). Ett lagrat objekt definierar medlemsfunktionen

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

som returnerar true om nyckelvärdet föregås och left inte är lika med nyckelvärdet right för i sorteringsordningen.

Exempel

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

Typen av objekt som lagras som ett element på en karta.

typedef pair<const Key, Type> value_type;

Exempel

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

Se även

Behållare
Trådsäkerhet i C++ Standard Library
Standardbiblioteksreferens för C++