hash_multimap-klass

2025-05-21

Anmärkning

Det här API:et är föråldrat. Alternativet är unordered_multimap-klass.

Containerklassen hash_multimap är ett tillägg till C++-standardbiblioteket och används för lagring och snabb hämtning av data från en samling där varje element är ett par som har en sorteringsnyckel vars värde inte behöver vara unikt och ett associerat datavärde.

Syntax

template <class Key,
    class Type,
    class Traits=hash_compare <Key, less <Key>>,
    class Allocator=allocator <pair  <const Key, Type>>>
class hash_multimap

Parameterar

Nyckel
Den nyckeldatatyp som ska lagras i hash_multimap.

Typ
Den elementdatatyp som ska lagras i hash_multimap.

egenskaper
Den typ som innehåller två funktionsobjekt, ett av klassegenskaper som kan jämföra två elementvärden som sorteringsnycklar för att fastställa deras relativa ordning och en hash-funktion som är en unary predikatmappningsnyckelvärden för elementen till osignerade heltal av typen size_t. Det här argumentet är valfritt och hash_compare<Key, less<Key>> är standardvärdet.

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

Anmärkningar

Hash_multimap är:

En associativ container, som en container med variabel storlek som stöder effektiv hämtning av elementvärden baserat på ett associerat nyckelvärde.
Reversibel eftersom den tillhandahåller en dubbelriktad iterator för att komma åt dess element.
Hashed, eftersom dess element grupperas i bucketar baserat på värdet för en hash-funktion som tillämpas på elementens nyckelvärden.
Flera, eftersom dess element inte behöver ha några unika nycklar, så att ett nyckelvärde kan ha många elementdatavärden kopplade till sig.
Ett par associativ container eftersom dess elementvärden skiljer sig från dess nyckelvärden.
En klassmall, eftersom den funktionalitet som den tillhandahåller är allmän och så oberoende av den specifika typen av data som ingår som element eller nycklar. De datatyper som ska användas för element och nycklar anges i stället som parametrar i klassmallen tillsammans med jämförelsefunktionen och allokeraren.

Den största fördelen med hashning över sortering är större effektivitet; en lyckad hashning utför infogningar, borttagningar och fynd i konstant genomsnittlig tid jämfört med en tid som är proportionell mot logaritmen för antalet element i containern för sorteringstekniker. Värdet för ett element i en hash_multimap, men inte dess associerade nyckelvärde, kan ändras direkt. I stället måste nyckelvärden som är associerade med gamla element tas bort och nya nyckelvärden som är associerade med nya element infogas.

Valet av containertyp bör i allmänhet baseras på vilken typ av sökning och infogning som krävs av programmet. Hashade associativa containrar är optimerade för åtgärder för sökning, infogning och borttagning. Medlemsfunktionerna som uttryckligen stöder dessa åtgärder är effektiva när de används med en väl utformad hash-funktion och utför dem i en tid som är i genomsnitt konstant och inte beroende av antalet element i containern. En väl utformad hashfunktion ger en enhetlig fördelning av hashvärden och minimerar antalet kollisioner, där en kollision sägs inträffa när distinkta nyckelvärden mappas till samma hashade värde. I värsta fall, med den värsta möjliga hashfunktionen, är antalet åtgärder proportionella mot antalet element i sekvensen (linjär tid).

Den hash_multimap bör vara den associativa container som ska väljas när villkoren som associerar värdena med deras nycklar uppfylls av programmet. En modell för den här typen av struktur är en ordnad lista med nyckelord med associerade strängvärden som tillhandahåller till exempel definitioner, där orden inte alltid har definierats unikt. Om nyckelorden i stället var unikt definierade så att nycklarna var unika skulle en hash_map vara valfri container. Om, å andra sidan, bara listan med ord lagras, skulle en hash_set vara rätt container. Om flera förekomster av orden tilläts skulle en hash_multiset vara rätt containerstruktur.

Hash_multimap beställer sekvensen som den styr genom att anropa ett lagrat hash-objekt Traits av typen value_compare. Det här lagrade objektet kan nås genom att anropa medlemsfunktionen key_comp. Ett sådant funktionsobjekt måste fungera på samma sätt som ett objekt av klass hash_compare<Key, less<Key>>. Specifikt ger anropet Key för alla värden Key av typen Traits (Key)en fördelning av värden av typen size_t.

I allmänhet behöver elementen bara vara mindre än jämförbara för att fastställa denna ordning, så att det, med tanke på två delar, kan fastställas antingen att de är likvärdiga (i den meningen att ingen av dem är mindre än den andra) eller att den ena är mindre än den andra. Detta resulterar i en ordning mellan de icke-likvärdiga elementen. På ett mer tekniskt sätt är jämförelsefunktionen ett binärt predikat som inducerar en strikt svag ordning i standard matematisk mening. Ett binärt predikat f(x, y) är ett funktionsobjekt som har två argumentobjekt x och y ett returvärde för true eller false. En ordning på en hash_multimap är en strikt svag ordning om det binära predikatet är irreflexivt, antisymmetriskt och transitivt och om ekvivalensen är transitiv, där två objekt x och y definieras som likvärdiga när både f(x, y) och f(y, x) är false. Om det starkare villkoret för likhet mellan nycklar ersätter likvärdighetens, blir ordningen total (i den meningen att alla element sorteras med avseende på varandra) och de nycklar som matchas kommer att vara urskiljbara från varandra.

Den faktiska ordningen på element i den kontrollerade sekvensen beror på hash-funktionen, ordningsfunktionen och den aktuella storleken på den hashtabell som lagras i containerobjektet. Du kan inte fastställa den aktuella storleken på hash-tabellen, så du kan inte i allmänhet förutsäga ordningen på element i den kontrollerade sekvensen. Om element infogas ogiltigförklaras inga iteratorer och om element tas bort ogiltigförklaras endast de iteratorer som specifikt har pekat på de borttagna elementen.

Iteratorn som tillhandahålls av klassen hash_multimap är en dubbelriktad iterator, men klassmedlemsfunktionerna infogar och hash_multimap har versioner som tar som mallparametrar en svagare iterator för indata, vars funktionskrav är mer minimala än de som garanteras av klassen för dubbelriktade iteratorer. De olika iteratorbegreppen utgör en familj som är relaterad till förbättringar i deras funktioner. Varje iteratorkoncept har sin egen hash_multimap av krav, och de algoritmer som fungerar med dem måste begränsa sina antaganden till de krav som tillhandahålls av den typen av iterator. Det kan antas att en indata-iterator kan derefereras för att referera till ett objekt och att det kan ökas till nästa iterator i sekvensen. Det här är en minimal hash_multimap av funktioner, men det räcker att kunna tala meningsfullt om en rad iteratorer [First, Last) i kontexten för medlemsfunktionerna.

Konstruktörer

Konstruktor	Beskrivning
hash_multimap	Konstruerar en lista med en viss storlek eller med element av ett visst värde eller med en specifik `allocator` eller som en kopia av någon annan `hash_multimap`.

Typedefs

Typnamn	Beskrivning
allocator_type	En typ som representerar klassen `allocator` för objektet `hash_multimap`.
const_iterator	En typ som tillhandahåller en dubbelriktad iterator som kan läsa ett `const` element i `hash_multimap`.
const_pointer	En typ som ger en pekare till ett `const` element i en `hash_multimap`.
const_reference	En typ som innehåller en referens till ett `const` element som lagras i en `hash_multimap` för att läsa och utföra `const` åtgärder.
const_reverse_iterator	En typ som tillhandahåller en dubbelriktad iterator som kan läsa alla `const` element i `hash_multimap`.
difference_type	En signerad heltalstyp som kan användas för att representera antalet element i ett `hash_multimap` i ett intervall mellan element som iteratorer pekar på.
iterator	En typ som tillhandahåller en dubbelriktad iterator som kan läsa eller ändra alla element i en `hash_multimap`.
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 `hash_multimap`.
key_type	En typ som beskriver sorteringsnyckelobjektet som utgör varje element i `hash_multimap`.
mapped_type	En typ som representerar datatypen som lagras i en `hash_multimap`.
pekare	En typ som ger en pekare till ett element i en `hash_multimap`.
hänvisning	En typ som innehåller en referens till ett element som lagras i en `hash_multimap`.
reverse_iterator	En typ som tillhandahåller en dubbelriktad iterator som kan läsa eller ändra ett element i en omvänd `hash_multimap`.
size_type	En osignerad heltalstyp som kan representera antalet element i en `hash_multimap`.
value_type	En typ som tillhandahåller ett funktionsobjekt som kan jämföra två element som sorteringsnycklar för att fastställa deras relativa ordning i `hash_multimap`.

Medlemsfunktioner

Medlemsfunktion	Beskrivning
börja	Returnerar en iterator som adresserar det första elementet i `hash_multimap`.
cbegin	Returnerar en const iterator som adresserar det första elementet `hash_multimap`i .
cend	Returnerar en const-iterator som adresserar platsen som lyckades med det sista elementet i en `hash_multimap`.
klar	Raderar alla element i en `hash_multimap`.
antal	Returnerar antalet element i en `hash_multimap` vars nyckel matchar en parameter angiven nyckel.
crbegin	Returnerar en const iterator som adresserar det första elementet i en omvänd `hash_multimap`.
crend	Returnerar en const-iterator som adresserar platsen som lyckades med det sista elementet i en omvänd `hash_multimap`.
emplace	Infogar ett element som konstruerats på plats i en `hash_multimap`.
emplace_hint	Infogar ett element som konstruerats på plats i en `hash_multimap`, med ett placeringstips.
tom	Testar om en `hash_multimap` är tom.
ände	Returnerar en iterator som adresserar platsen som lyckades med det sista elementet i en `hash_multimap`.
equal_range	Returnerar en iterator som adresserar platsen som lyckades med det sista elementet i en `hash_multimap`.
radera	Tar bort ett element eller ett område med element i en `hash_multimap` från angivna positioner
hitta	Returnerar en iterator som adresserar platsen för ett element i en `hash_multimap` som har en nyckel som motsvarar en angiven nyckel.
get_allocator	Returnerar en kopia av objektet `allocator` som används för att konstruera `hash_multimap`.
infoga	Infogar ett element eller ett område med element i `hash_multimap` en angiven position.
key_comp	Hämtar en kopia av jämförelseobjektet som används för att beställa nycklar i en `hash_multimap`.
lower_bound	Returnerar en iterator till det första elementet i ett `hash_multimap` som med ett nyckelvärde som är lika med eller större än värdet för en angiven nyckel.
max_size	Returnerar den maximala längden på `hash_multimap`.
rbegin	Returnerar en iterator som adresserar det första elementet i en omvänd `hash_multimap`.
rend	Returnerar en iterator som adresserar platsen som lyckades det sista elementet i en omvänd `hash_multimap`.
storlek	Anger en ny storlek för en `hash_multimap`.
växla	Utbyter elementen i två `hash_multimap`s.
upper_bound	Returnerar en iterator till det första elementet i ett `hash_multimap` som med ett nyckelvärde som är större än för en angiven nyckel.
value_comp	Hämtar en kopia av jämförelseobjektet som används för att beställa elementvärden i en `hash_multimap`.

Operatörer

Operatör	Beskrivning
hash_multimap::operator=	Ersätter elementen i en `hash_multimap` med en kopia av en annan `hash_multimap`.

Kravspecifikation

Rubrik:<hash_map>

Namnområde: stdext

hash_multimap::allocator_type

Anmärkning

Det här API:et är föråldrat. Alternativet är unordered_multimap-klass.

En typ som representerar allokeringsklassen för det hash_multimap objektet.

typedef list<typename Traits::value_type, typename Traits::allocator_type>::allocator_type allocator_type;

Anmärkningar

allocator_type är synonymt med mallparametern Allocator.

Mer information om Allocatorfinns i avsnittet Anmärkningar i avsnittet hash_multimap-klass .

Exempel

Se exemplet för get_allocator för ett exempel med hjälp av allocator_type.

hash_multimap::begin

Anmärkning

Det här API:et är föråldrat. Alternativet är unordered_multimap-klass.

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

const_iterator begin() const;

iterator begin();

Returvärde

En dubbelriktad iterator som adresserar det första elementet i hash_multimap eller platsen som lyckas med en tom hash_multimap.

Anmärkningar

Om returvärdet begin för har tilldelats till ett const_iteratorkan elementen i hash_multimap-objektet inte ändras. Om returvärdet begin för har tilldelats till ett iteratorkan elementen i hash_multimap-objektet ändras.

Exempel

// hash_multimap_begin.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_multimap <int, int> hm1;

   hash_multimap <int, int> :: iterator hm1_Iter;
   hash_multimap <int, int> :: const_iterator hm1_cIter;
   typedef pair <int, int> Int_Pair;

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

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

   hm1_Iter = hm1.begin ( );
   hm1.erase ( hm1_Iter );

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

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

The first element of hm1 is 0.
The first element of hm1 is now 1.

hash_multimap::cbegin

Anmärkning

Det här API:et är föråldrat. Alternativet är unordered_multimap-klass.

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

const_iterator cbegin() const;

Returvärde

En dubbelriktad iterator som hanterar det första elementet i hash_multimap eller platsen som lyckas med en tom hash_multimap.

Exempel

// hash_multimap_cbegin.cpp
// compile with: /EHsc
#include <hash_multimap>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_multimap <int, int> hm1;

   hash_multimap <int, int> :: const_iterator hm1_cIter;
   typedef pair <int, int> Int_Pair;

   hm1.insert ( Int_Pair ( 2, 4 ) );

   hm1_cIter = hm1.cbegin ( );
   cout << "The first element of hm1 is "
        << hm1_cIter -> first << "." << endl;
   }

The first element of hm1 is 2.

hash_multimap::cend

Anmärkning

Det här API:et är föråldrat. Alternativet är unordered_multimap-klass.

Returnerar en const iterator som adresserar platsen som lyckades med det sista elementet i en hash_multimap.

const_iterator cend() const;

Returvärde

En dubbelriktad iterator som adresserar platsen som lyckades med det sista elementet i en hash_multimap. Om hash_multimap är tom hash_multimap::cend == hash_multimap::begin.

Anmärkningar

cend används för att testa om en iterator har nått slutet av sin hash_multimap.

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

Exempel

// hash_multimap_cend.cpp
// compile with: /EHsc
#include <hash_multimap>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_multimap <int, int> hm1;

   hash_multimap <int, int> :: const_iterator hm1_cIter;
   typedef pair <int, int> Int_Pair;

   hm1.insert ( Int_Pair ( 3, 30 ) );

   hm1_cIter = hm1.cend( );
   hm1_cIter--;
   cout << "The value of last element of hm1 is "
        << hm1_cIter -> second << "." << endl;
   }

The value of last element of hm1 is 30.

hash_multimap::clear

Anmärkning

Det här API:et är föråldrat. Alternativet är unordered_multimap-klass.

Raderar alla element i en hash_multimap.

void clear();

Anmärkningar

Exempel

I följande exempel visas hur funktionen hash_multimap::clear member används.

// hash_multimap_clear.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main()
{
    using namespace std;
    using namespace stdext;
    hash_multimap<int, int> hm1;
    hash_multimap<int, int>::size_type i;
    typedef pair<int, int> Int_Pair;

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

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

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

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

hash_multimap::const_iterator

Anmärkning

Det här API:et är föråldrat. Alternativet är unordered_multimap-klass.

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

typedef list<typename Traits::value_type, typename Traits::allocator_type>::const_iterator const_iterator;

Anmärkningar

Det går inte att använda en typ const_iterator för att ändra värdet för ett element.

Definierad const_iterator av hash_multimap pekar på objekt av value_type, som är av typen pair<const Key, Type>. Värdet för nyckeln är tillgängligt via det första medlemsparet och värdet för det mappade elementet är tillgängligt via den andra medlemmen i paret.

Om du vill avreferering av en const_iteratorcIter pekar på ett element i en hash_multimap 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 exemplet för att börja för ett exempel med hjälp av const_iterator.

hash_multimap::const_pointer

Anmärkning

Det här API:et är föråldrat. Alternativet är unordered_multimap-klass.

En typ som ger en pekare till ett const element i en hash_multimap.

typedef list<typename _Traits::value_type, typename _Traits::allocator_type>::const_pointer const_pointer;

Anmärkningar

Det går inte att använda en typ const_pointer 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 hash_multimap objekt.

hash_multimap::const_reference

Anmärkning

Det här API:et är föråldrat. Alternativet är unordered_multimap-klass.

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

typedef list<typename _Traits::value_type, typename _Traits::allocator_type>::const_reference const_reference;

Anmärkningar

Exempel

// hash_multimap_const_ref.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_multimap<int, int> hm1;
   typedef pair <int, int> Int_Pair;

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

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

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

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

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

   cout << "The data value of 1st element in the hash_multimap is "
        << Ref2 << "." << endl;
}

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

hash_multimap::const_reverse_iterator

Anmärkning

Det här API:et är föråldrat. Alternativet är unordered_multimap-klass.

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

typedef list<typename Traits::value_type, typename Traits::allocator_type>::const_reverse_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 hash_multimap i omvänd ordning.

Definierad const_reverse_iterator av hash_multimap pekar på 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_iteratorcrIter pekar på ett element i en hash_multimap 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).second.

Exempel

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

hash_multimap::count

Anmärkning

Det här API:et är föråldrat. Alternativet är unordered_multimap-klass.

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

size_type count(const Key& key) const;

Parameterar

nyckel
Nyckeln för de element som ska matchas från hash_multimap.

Returvärde

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

Anmärkningar

Medlemsfunktionen returnerar antalet element i intervallet

[lower_bound (key), upper_bound (key) )

som har en nyckelvärdenyckel.

Exempel

I följande exempel visas användningen av funktionen hash_multimap::count member.

// hash_multimap_count.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
    using namespace std;
    using namespace stdext;
    hash_multimap<int, int> hm1;
    hash_multimap<int, int>::size_type i;
    typedef pair<int, int> Int_Pair;

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

    // Elements do not need to have unique keys in hash_multimap,
    // so duplicates are allowed and counted
    i = hm1.count(1);
    cout << "The number of elements in hm1 with a sort key of 1 is: "
         << i << "." << endl;

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

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

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

hash_multimap::crbegin

Anmärkning

Det här API:et är föråldrat. Alternativet är unordered_multimap-klass.

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

const_reverse_iterator crbegin() const;

Returvärde

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

Anmärkningar

crbeginanvänds med en omvänd hash_multimap precis som hash_multimap::begin används med .hash_multimap

Med returvärdet kan crbeginhash_multimap objektet inte ändras.

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

Exempel

// hash_multimap_crbegin.cpp
// compile with: /EHsc
#include <hash_multimap>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_multimap <int, int> hm1;

   hash_multimap <int, int> :: const_reverse_iterator hm1_crIter;
   typedef pair <int, int> Int_Pair;

   hm1.insert ( Int_Pair ( 3, 30 ) );

   hm1_crIter = hm1.crbegin( );
   cout << "The first element of the reversed hash_multimap hm1 is "
        << hm1_crIter -> first << "." << endl;
}

The first element of the reversed hash_multimap hm1 is 3.

hash_multimap::crend

Anmärkning

Det här API:et är föråldrat. Alternativet är unordered_multimap-klass.

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

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 hash_multimap (platsen som hade föregått det första elementet i det oreverserade hash_multimap).

Anmärkningar

crend används med omvända hash_multimap precis som hash_multimap::end används med en hash_multimap.

Med returvärdet kan crendhash_multimap objektet inte ändras.

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

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

Exempel

// hash_multimap_crend.cpp
// compile with: /EHsc
#include <hash_multimap>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_multimap <int, int> hm1;

   hash_multimap <int, int> :: const_reverse_iterator hm1_crIter;
   typedef pair <int, int> Int_Pair;

   hm1.insert ( Int_Pair ( 3, 30 ) );

   hm1_crIter = hm1.crend( );
   hm1_crIter--;
   cout << "The last element of the reversed hash_multimap hm1 is "
        << hm1_crIter -> first << "." << endl;
}

The last element of the reversed hash_multimap hm1 is 3.

hash_multimap::d ifference_type

Anmärkning

Det här API:et är föråldrat. Alternativet är unordered_multimap-klass.

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

typedef list<typename _Traits::value_type, typename _Traits::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.

Observera att ä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 iteratorer med slumpmässig åtkomst som tillhandahålls av en container med slumpmässig åtkomst, till exempel vektor.

Exempel

// hash_multimap_difference_type.cpp
// compile with: /EHsc
#include <iostream>
#include <hash_map>
#include <algorithm>

int main()
{
    using namespace std;
    using namespace stdext;
    hash_multimap<int, int> hm1;
    typedef pair<int, int> Int_Pair;

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

    // The following will insert, because map keys
    // do not need to be unique
    hm1.insert(Int_Pair(2, 30));

    hash_multimap<int, int>::iterator hm1_Iter, hm1_bIter, hm1_eIter;
    hm1_bIter = hm1.begin();
    hm1_eIter = hm1.end();

    // Count the number of elements in a hash_multimap
    hash_multimap<int, int>::difference_type df_count = 0;
    hm1_Iter = hm1.begin();
    while (hm1_Iter != hm1_eIter)
    {
        df_count++;
        hm1_Iter++;
    }

    cout << "The number of elements in the hash_multimap hm1 is: "
         << df_count << "." << endl;

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

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

The number of elements in the hash_multimap hm1 is: 4.
The keys of the mapped elements are: 1 2 2 3.
The values of the mapped elements are: 10 20 30 20.

hash_multimap::emplace

Anmärkning

Det här API:et är föråldrat. Alternativet är unordered_multimap-klass.

Infogar ett element som är konstruerat på plats i en hash_multimap.

template <class ValTy>
iterator emplace(ValTy&& val);

Parameterar

val
Värdet som används för att flytta konstruktionen av ett element som ska infogas i hash_multimap.

Returvärde

Medlemsfunktionen emplace returnerar en iterator som pekar på positionen där det nya elementet infogades.

Anmärkningar

Hash_multimap::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 lika med elementets datavärde.

Exempel

// hash_multimap_emplace.cpp
// compile with: /EHsc
#include <hash_multimap>
#include <iostream>
#include <string>

int main()
{
    using namespace std;
    using namespace stdext;
    hash_multimap<int, string> hm1;
    typedef pair<int, string> is1(1, "a");

    hm1.emplace(move(is1));
    cout << "After the emplace, hm1 contains:" << endl
      << " " << hm1.begin()->first
      << " => " << hm1.begin()->second
      << endl;
}

After the emplace insertion, hm1 contains:
1 => a

hash_multimap::emplace_hint

Anmärkning

Det här API:et är föråldrat. Alternativet är unordered_multimap-klass.

Infogar ett element som är konstruerat på plats i en hash_multimap med ett placeringstips.

template <class ValTy>
iterator emplace_hint(
    const_iterator _Where,
    ValTy&& val);

Parameterar

val
Värdet som används för att flytta konstruera ett element som ska infogas i hash_multimap om inte det hash_multimap redan innehåller elementet (eller, mer allmänt, ett element vars nyckel är motsvarande ordnad).

_Var
Ett tips om platsen där du kan börja söka efter rätt insättningspunkt.

Returvärde

Funktionen hash_multimap::emplace member returnerar en iterator som pekar på positionen där det nya elementet infogades i hash_multimap.

Anmärkningar

Infogning kan ske i amorterad konstant tid, i stället för logaritmisk tid, om insättningspunkten omedelbart följer _Where.

Exempel

// hash_multimap_emplace_hint.cpp
// compile with: /EHsc
#include <hash_multimap>
#include <iostream>
#include <string>

int main()
{
    using namespace std;
    using namespace stdext;
    hash_multimap<int, string> hm1;
    typedef pair<int, string> is1(1, "a");

    hm1.emplace(hm1.begin(), move(is1));
    cout << "After the emplace insertion, hm1 contains:" << endl
      << " " << hm1.begin()->first
      << " => " << hm1.begin()->second
      << endl;
}

After the emplace insertion, hm1 contains:
1 => a

hash_multimap::empty

Anmärkning

Det här API:et är föråldrat. Alternativet är unordered_multimap-klass.

Testar om en hash_multimap är tom.

bool empty() const;

Returvärde

true om hash_multimap är tom; false om hash_multimap inte är något.

Anmärkningar

Exempel

// hash_multimap_empty.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_multimap <int, int> hm1, hm2;

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

   if ( hm1.empty( ) )
      cout << "The hash_multimap hm1 is empty." << endl;
   else
      cout << "The hash_multimap hm1 is not empty." << endl;

   if ( hm2.empty( ) )
      cout << "The hash_multimap hm2 is empty." << endl;
   else
      cout << "The hash_multimap hm2 is not empty." << endl;
}

The hash_multimap hm1 is not empty.
The hash_multimap hm2 is empty.

hash_multimap::end

Anmärkning

Det här API:et är föråldrat. Alternativet är unordered_multimap-klass.

Returnerar en iterator som adresserar platsen som lyckas med det sista elementet i en hash_multimap.

const_iterator end() const;

iterator end();

Returvärde

En dubbelriktad iterator som adresserar platsen som lyckades med det sista elementet i en hash_multimap. Om hash_multimap är tom hash_multimap::end == hash_multimap::begin.

Anmärkningar

end används för att testa om en iterator har nått slutet av sin hash_multimap.

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

Exempel

// hash_multimap_end.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_multimap <int, int> hm1;

   hash_multimap <int, int> :: iterator hm1_Iter;
   hash_multimap <int, int> :: const_iterator hm1_cIter;
   typedef pair <int, int> Int_Pair;

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

   hm1_cIter = hm1.end( );
   hm1_cIter--;
   cout << "The value of last element of hm1 is "
        << hm1_cIter -> second << "." << endl;

   hm1_Iter = hm1.end( );
   hm1_Iter--;
   hm1.erase ( hm1_Iter );

   // The following 2 lines would err because the iterator is const
   // hm1_cIter = hm1.end ( );
   // hm1_cIter--;
   // hm1.erase ( hm1_cIter );

   hm1_cIter = hm1.end( );
   hm1_cIter--;
   cout << "The value of last element of hm1 is now "
        << hm1_cIter -> second << "." << endl;
}

The value of last element of hm1 is 30.
The value of last element of hm1 is now 20.

hash_multimap::equal_range

Anmärkning

Det här API:et är föråldrat. Alternativet är unordered_multimap-klass.

Returnerar ett par iteratorer till det första elementet i en hash_multimap med en nyckel som är större än en angiven nyckel och till det första elementet i hash_multimap med en nyckel som är lika med eller större än nyckeln.

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

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

Parameterar

nyckel
Argumentnyckeln som ska jämföras med sorteringsnyckeln för ett element från hash_multimap som genomsöks.

Returvärde

Ett par iteratorer så att den första är nyckelns lower_bound och den andra är nyckelns upper_bound .

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 för att avreferering av den lägre bundna iteratorn 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).

Anmärkningar

Exempel

// hash_multimap_equal_range.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   typedef hash_multimap <int, int> IntMMap;
   IntMMap hm1;
   hash_multimap <int, int> :: const_iterator hm1_RcIter;
   typedef pair <int, int> Int_Pair;

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

   pair <IntMMap::const_iterator, IntMMap::const_iterator> p1, p2;
   p1 = hm1.equal_range( 2 );

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

   cout << "The upper bound of the element with a key of 2\n"
        << "in the hash_multimap hm1 is: "
        << p1.second -> second << "." << endl;

   // Compare the upper_bound called directly
   hm1_RcIter = hm1.upper_bound( 2 );

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

   p2 = hm1.equal_range( 4 );

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

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

hash_multimap::erase

Anmärkning

Det här API:et är föråldrat. Alternativet är unordered_multimap-klass.

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

iterator erase(iterator _Where);

iterator erase(iterator first, iterator last);

size_type erase(const key_type& key);

Parameterar

_Var
Positionen för elementet som ska tas bort från hash_multimap.

första
Positionen för det första elementet som tagits bort från hash_multimap.

senaste
Placera precis utanför det sista elementet som togs bort från hash_multimap.

nyckel
Nyckeln för de element som ska tas bort från hash_multimap.

Returvärde

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

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

Anmärkningar

Medlemsfunktionerna utlöser aldrig ett undantag.

Exempel

I följande exempel visas hur medlemsfunktionen hash_multimap::erase används.

// hash_multimap_erase.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main()
{
    using namespace std;
    using namespace stdext;
    hash_multimap<int, int> hm1, hm2, hm3;
    hash_multimap<int, int> :: iterator pIter, Iter1, Iter2;
    int i;
    hash_multimap<int, int>::size_type n;
    typedef pair<int, int> Int_Pair;

    for (i = 1; i < 5; i++)
    {
        hm1.insert(Int_Pair (i, i) );
        hm2.insert(Int_Pair (i, i*i) );
        hm3.insert(Int_Pair (i, i-1) );
    }

    // The 1st member function removes an element at a given position
    Iter1 = ++hm1.begin();
    hm1.erase(Iter1);

    cout << "After the 2nd element is deleted, "
         << "the hash_multimap hm1 is:";
    for (pIter = hm1.begin(); pIter != hm1.end(); pIter++)
        cout << " " << pIter -> second;
    cout << "." << endl;

    // The 2nd member function removes elements
    // in the range [ first,  last)
    Iter1 = ++hm2.begin();
    Iter2 = --hm2.end();
    hm2.erase(Iter1, Iter2);

    cout << "After the middle two elements are deleted, "
         << "the hash_multimap hm2 is:";
    for (pIter = hm2.begin(); pIter != hm2.end(); pIter++)
        cout << " " << pIter -> second;
    cout << "." << endl;

    // The 3rd member function removes elements with a given  key
    hm3.insert(Int_Pair (2, 5));
    n = hm3.erase(2);

    cout << "After the element with a key of 2 is deleted,\n"
         << "the hash_multimap hm3 is:";
    for (pIter = hm3.begin(); pIter != hm3.end(); pIter++)
        cout << " " << pIter -> second;
    cout << "." << endl;

    // The 3rd member function returns the number of elements removed
    cout << "The number of elements removed from hm3 is: "
         << n << "." << endl;

    // The dereferenced iterator can also be used to specify a key
    Iter1 = ++hm3.begin();
    hm3.erase(Iter1);

    cout << "After another element with a key equal to that of the"
         << endl;
    cout  << "2nd element is deleted, "
          << "the hash_multimap hm3 is:";
    for (pIter = hm3.begin(); pIter != hm3.end(); pIter++)
        cout << " " << pIter -> second;
    cout << "." << endl;
}

After the 2nd element is deleted, the hash_multimap hm1 is: 1 3 4.
After the middle two elements are deleted, the hash_multimap hm2 is: 1 16.
After the element with a key of 2 is deleted,
the hash_multimap hm3 is: 0 2 3.
The number of elements removed from hm3 is: 2.
After another element with a key equal to that of the
2nd element is deleted, the hash_multimap hm3 is: 0 3.

hash_multimap::find

Anmärkning

Det här API:et är föråldrat. Alternativet är unordered_multimap-klass.

Returnerar en iterator som adresserar den första platsen för ett element i en hash_multimap som har en nyckel som motsvarar en angiven nyckel.

iterator find(const Key& key);

const_iterator find(const Key& key) const;

Parameterar

nyckel
Nyckeln som ska matchas av sorteringsnyckeln för ett element från hash_multimap som genomsöks.

Returvärde

En iterator som adresserar den första platsen för ett element med en angiven nyckel, eller platsen som lyckas med det sista elementet i hash_multimap om ingen matchning hittas för nyckeln.

Anmärkningar

Medlemsfunktionen returnerar en iterator som adresserar ett element i hash_multimap vars sorteringsnyckel är equivalent till argumentnyckeln under ett binärt predikat som inducerar en ordning baserat på en relation med mindre än jämförbarhet.

Om returvärdet find för har tilldelats till ett const_iteratorkan hash_multimap-objektet inte ändras. Om returvärdet find för har tilldelats till ett iteratorkan hash_multimap-objektet ändras.

Exempel

// hash_multimap_find.cpp
// compile with: /EHsc
#include <iostream>
#include <hash_map>

int main()
{
    using namespace std;
    using namespace stdext;
    hash_multimap<int, int> hm1;
    hash_multimap<int, int> :: const_iterator hm1_AcIter, hm1_RcIter;
    typedef pair<int, int> Int_Pair;

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

    hm1_RcIter = hm1.find(2);
    cout << "The element of hash_multimap hm1 with a key of 2 is: "
          << hm1_RcIter -> second << "." << endl;

    hm1_RcIter = hm1.find(3);
    cout << "The first element of hash_multimap hm1 with a key of 3 is: "
          << hm1_RcIter -> second << "." << endl;

    // If no match is found for the key, end() is returned
    hm1_RcIter = hm1.find(4);

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

    // The element at a specific location in the hash_multimap can be
    // found using a dereferenced iterator addressing the location
    hm1_AcIter = hm1.end();
    hm1_AcIter--;
    hm1_RcIter = hm1.find(hm1_AcIter -> first);
    cout << "The first element of hm1 with a key matching"
         << endl << "that of the last element is: "
         << hm1_RcIter -> second << "." << endl;

    // Note that the first element with a key equal to
    // the key of the last element is not the last element
    if (hm1_RcIter == --hm1.end())
        cout << "This is the last element of hash_multimap hm1."
             << endl;
    else
        cout << "This is not the last element of hash_multimap hm1."
             << endl;
}

The element of hash_multimap hm1 with a key of 2 is: 20.
The first element of hash_multimap hm1 with a key of 3 is: 20.
The hash_multimap hm1 doesn't have an element with a key of 4.
The first element of hm1 with a key matching
that of the last element is: 20.
This is not the last element of hash_multimap hm1.

hash_multimap::get_allocator

Anmärkning

Det här API:et är föråldrat. Alternativet är unordered_multimap-klass.

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

Allocator get_allocator() const;

Returvärde

Allokeraren som används av hash_multimap.

Anmärkningar

Allokerare för klassen hash_multimap 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

// hash_multimap_get_allocator.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_multimap <int, int>::allocator_type hm1_Alloc;
   hash_multimap <int, int>::allocator_type hm2_Alloc;
   hash_multimap <int, double>::allocator_type hm3_Alloc;
   hash_multimap <int, int>::allocator_type hm4_Alloc;

   // The following lines declare objects
   // that use the default allocator.
   hash_multimap <int, int> hm1;
   hash_multimap <int, int> hm2;
   hash_multimap <int, double> hm3;

   hm1_Alloc = hm1.get_allocator( );
   hm2_Alloc = hm2.get_allocator( );
   hm3_Alloc = hm3.get_allocator( );

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

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

   // The following line creates a hash_multimap hm4
   // with the allocator of hash_multimap hm1.
   hash_multimap <int, int> hm4( less<int>( ), hm1_Alloc );

   hm4_Alloc = hm4.get_allocator( );

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

hash_multimap::hash_multimap

Anmärkning

Det här API:et är föråldrat. Alternativet är unordered_multimap-klass.

Konstruerar en hash_multimap som är tom eller är en kopia av alla eller en del av någon annan hash_multimap.

hash_multimap();

explicit hash_multimap(
    const Compare& Comp);

hash_multimap(
    const Compare& Comp,
    const Allocator& Al);

hash_multimap(
    const hash_multimap& Right);

hash_multimap(
    hash_multimap&& Right);

hash_multimap(
    initializer_list<Type> IList);

hash_multimap(
    initializer_list<Type> IList,
    const Compare& Comp);

hash_multimap(
    initializer_list<Type> IList,
    const Compare& Comp,
    const Allocator& Al);

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

template <class InputIterator>
hash_multimap(
    InputIterator First,
    InputIterator Last,
    const Compare& Comp);

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

Parameterar

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

Komp
Jämförelsefunktionen av typen const Traits som används för att sortera elementen på kartan, som standard är Traits.

höger
Kartan som den konstruerade uppsättningen ska vara en kopia av.

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

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

IList
Den initializer_list att kopiera från.

Anmärkningar

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

Alla konstruktorer initierar sina hash_multimap.

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

De första tre konstruktorerna anger en tom inledande hash_multimap. 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 utelämnar vissa typer av automatisk typkonvertering.

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

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.

Den åttonde konstruktorn flyttar hash_multimap Right.

De tre sista konstruktorerna använder en initializer_list.

hash_multimap::insert

Anmärkning

Det här API:et är föråldrat. Alternativet är unordered_multimap-klass.

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

iterator insert(
    const value_type& Val);

iterator insert(
    const_iterator Where,
    const value_type& Val);void insert(
    initializer_list<value_type> IList);

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

template <class ValTy>
iterator insert(
    ValTy&& Val);

template <class ValTy>
iterator insert(
    const_iterator Where,
    ValTy&& Val);

Parameterar

Val
Värdet för ett element som ska infogas i hash_multimap om det inte redan innehåller elementet, eller mer allmänt, såvida det inte redan innehåller ett element vars nyckel är ordnad på motsvarande sätt.

Var
En ledtråd om var du ska börja söka efter rätt insättningspunkt.

Första
Positionen för det första elementet som kopieras från en karta.

senaste
Positionen precis utanför det sista element som kopieras från en karta.

Returvärde

De två insert första medlemsfunktionerna returnerar en iterator som pekar på positionen där det nya elementet infogades.

Den tredje medlemsfunktionen använder en initializer_list för att elementen ska infogas.

Den fjärde medlemsfunktionen infogar sekvensen med elementvärden i en karta som motsvarar varje element som hanteras av en iterator i intervallet [First, Last) för en angiven uppsättning.

De två insert sista medlemsfunktionerna fungerar på samma sätt som de två första, förutom att de flyttar det infogade värdet.

Anmärkningar

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

Infogning kan ske i amorterad konstant tid för tipsversionen av insert, i stället för logaritmisk tid, om insättningspunkten omedelbart följer Var.

hash_multimap::iterator

Anmärkning

Det här API:et är föråldrat. Alternativet är unordered_multimap-klass.

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

typedef list<typename Traits::value_type, typename Traits::allocator_type>::iterator iterator;

Anmärkningar

Definierad iterator av hash_multimap pekar på 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 iterator med namnet Iter som pekar på ett element i en hash_multimap 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).first.

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

Exempel

I exemplet för att börja finns ett exempel på hur du deklarerar och använder iterator.

hash_multimap::key_comp

Anmärkning

Det här API:et är föråldrat. Alternativet är unordered_multimap-klass.

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

key_compare key_comp() const;

Returvärde

Returnerar det funktionsobjekt som en hash_multimap 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

// hash_multimap_key_comp.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;

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

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

hash_multimap::key_compare

Anmärkning

Det här API:et är föråldrat. Alternativet är unordered_multimap-klass.

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 hash_multimap.

typedef Traits key_compare;

Anmärkningar

key_compare är en synonym för mallparametern Egenskaper.

Mer information om egenskaper finns i avsnittet hash_multimap Class .

Exempel

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

hash_multimap::key_type

Anmärkning

Det här API:et är föråldrat. Alternativet är unordered_multimap-klass.

En typ som beskriver sorteringsnyckelobjektet som utgör varje element i hash_multimap.

typedef Key key_type;

Anmärkningar

key_type är en synonym för mallparameternyckeln.

Mer information om nyckel finns i avsnittet Kommentarer i avsnittet hash_multimap Class .

Exempel

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

hash_multimap::lower_bound

Anmärkning

Det här API:et är föråldrat. Alternativet är unordered_multimap-klass.

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

iterator lower_bound(const Key& key);

const_iterator lower_bound(const Key& key) const;

Parameterar

nyckel
Argumentnyckeln som ska jämföras med sorteringsnyckeln för ett element från hash_multimap som genomsöks.

Returvärde

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

Om returvärdet lower_bound för har tilldelats till ett const_iteratorkan hash_multimap-objektet inte ändras. Om returvärdet lower_bound för har tilldelats till ett iteratorkan hash_multimap-objektet ändras.

Anmärkningar

Exempel

// hash_multimap_lower_bound.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_multimap <int, int> hm1;
   hash_multimap <int, int> :: const_iterator hm1_AcIter,
      hm1_RcIter;
   typedef pair <int, int> Int_Pair;

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

   hm1_RcIter = hm1.lower_bound( 2 );
   cout << "The element of hash_multimap hm1 with a key of 2 is: "
        << hm1_RcIter -> second << "." << endl;

   hm1_RcIter = hm1.lower_bound( 3 );
   cout << "The first element of hash_multimap hm1 with a key of 3 is: "
        << hm1_RcIter -> second << "." << endl;

   // If no match is found for the key, end( ) is returned
   hm1_RcIter = hm1.lower_bound( 4 );

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

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

   // Note that the first element with a key equal to
   // the key of the last element is not the last element
   if ( hm1_RcIter == --hm1.end( ) )
      cout << "This is the last element of hash_multimap hm1."
           << endl;
   else
      cout << "This is not the last element of hash_multimap hm1."
           << endl;
}

The element of hash_multimap hm1 with a key of 2 is: 20.
The first element of hash_multimap hm1 with a key of 3 is: 20.
The hash_multimap hm1 doesn't have an element with a key of 4.
The first element of hm1 with a key matching
that of the last element is: 20.
This is not the last element of hash_multimap hm1.

hash_multimap::mapped_type

Anmärkning

Det här API:et är föråldrat. Alternativet är unordered_multimap-klass.

En typ som representerar datatypen som lagras i en hash_multimap.

typedef Type mapped_type;

Anmärkningar

mapped_type är en synonym för mallparametern Typ.

Mer information om Typ finns i avsnittet hash_multimap Class .

Exempel

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

hash_multimap::max_size

Anmärkning

Det här API:et är föråldrat. Alternativet är unordered_multimap-klass.

Returnerar den maximala längden på hash_multimap.

size_type max_size() const;

Returvärde

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

Anmärkningar

Exempel

// hash_multimap_max_size.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_multimap <int, int> hm1;
   hash_multimap <int, int> :: size_type i;

   i = hm1.max_size( );
   cout << "The maximum possible length "
        << "of the hash_multimap is " << i << "." << endl;
}

hash_multimap::operator=

Anmärkning

Det här API:et är föråldrat. Alternativet är unordered_multimap-klass.

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

hash_multimap& operator=(const hash_multimap& right);

hash_multimap& operator=(hash_multimap&& right);

Parameterar

rätt
Den hash_multimap som kopieras till hash_multimap.

Anmärkningar

När du har raderat befintliga element i en hash_multimapkopierar operator= eller flyttar du innehållet i höger till hash_multimap.

Exempel

// hash_multimap_operator_as.cpp
// compile with: /EHsc
#include <hash_multimap>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_multimap<int, int> v1, v2, v3;
   hash_multimap<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;
}

hash_multimap::p ointer

Anmärkning

Det här API:et är föråldrat. Alternativet är unordered_multimap-klass.

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

typedef list<typename _Traits::value_type, typename _Traits::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 hash_multimap objekt.

hash_multimap::rbegin

Anmärkning

Det här API:et är föråldrat. Alternativet är unordered_multimap-klass.

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

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 hash_multimap eller som behandlar vad som hade varit det sista elementet i det olästa hash_multimap.

Anmärkningar

rbegin används med omvända hash_multimap precis som i början används med en hash_multimap.

Om returvärdet rbegin för har tilldelats till en const_reverse_iteratorkan hash_multimap-objektet inte ändras. Om returvärdet rbegin för har tilldelats till en reverse_iteratorkan hash_multimap-objektet ändras.

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

Exempel

// hash_multimap_rbegin.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_multimap <int, int> hm1;

   hash_multimap <int, int> :: iterator hm1_Iter;
   hash_multimap <int, int> :: reverse_iterator hm1_rIter;
   hash_multimap <int, int> :: const_reverse_iterator hm1_crIter;
   typedef pair <int, int> Int_Pair;

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

   hm1_rIter = hm1.rbegin( );
   cout << "The first element of the reversed hash_multimap hm1 is "
        << hm1_rIter -> first << "." << endl;

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

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

   // A hash_multimap element can be erased by dereferencing its key
   hm1_rIter = hm1.rbegin( );
   hm1.erase ( hm1_rIter -> first );

   hm1_rIter = hm1.rbegin( );
   cout << "After the erasure, the first element\n"
        << "in the reversed hash_multimap is "
        << hm1_rIter -> first << "." << endl;
}

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

hash_multimap::reference

Anmärkning

Det här API:et är föråldrat. Alternativet är unordered_multimap-klass.

En typ som ger en referens till ett element som lagras i en hash_multimap.

typedef list<typename _Traits::value_type, typename _Traits::allocator_type>::reference reference;

Anmärkningar

Exempel

// hash_multimap_reference.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_multimap <int, int> hm1;
   typedef pair <int, int> Int_Pair;

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

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

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

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

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

   cout << "The data value of first element in the hash_multimap 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 hash_multimap is 1.
The data value of first element in the hash_multimap is 10.
The modified data value of first element is 15.

hash_multimap::rend

Anmärkning

Det här API:et är föråldrat. Alternativet är unordered_multimap-klass.

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

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 hash_multimap (platsen som hade föregått det första elementet i den oreverserade hash_multimap).

Anmärkningar

rend används med omvända hash_multimap precis som slutet används med en hash_multimap.

Om returvärdet rend för tilldelas till en const_reverse_iterator kan hash_multimap-objektet inte ändras. Om returvärdet rend för har tilldelats till en reverse_iterator kan hash_multimap-objektet ändras.

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

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

Exempel

// hash_multimap_rend.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_multimap <int, int> hm1;

   hash_multimap <int, int> :: iterator hm1_Iter;
   hash_multimap <int, int> :: reverse_iterator hm1_rIter;
   hash_multimap <int, int> :: const_reverse_iterator hm1_crIter;
   typedef pair <int, int> Int_Pair;

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

   hm1_rIter = hm1.rend( );
   hm1_rIter--;
   cout << "The last element of the reversed hash_multimap hm1 is "
        << hm1_rIter -> first << "." << endl;

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

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

   // A hash_multimap element can be erased by dereferencing its key
   hm1_rIter = --hm1.rend( );
   hm1.erase ( hm1_rIter -> first );

   hm1_rIter = hm1.rend( );
   hm1_rIter--;
   cout << "After the erasure, the last element "
        << "in the reversed hash_multimap is "
        << hm1_rIter -> first << "." << endl;
}

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

hash_multimap::reverse_iterator

Anmärkning

Det här API:et är föråldrat. Alternativet är unordered_multimap-klass.

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

typedef list<typename Traits::value_type, typename Traits::allocator_type>::reverse_iterator reverse_iterator;

Anmärkningar

En typ reverse_iterator används för att iterera genom hash_multimap i omvänd ordning.

Definierad reverse_iterator av hash_multimap pekar på objekt av value_type, som är av typen pair<const Key, Type>. Värdet för nyckeln är tillgängligt via det första medlemsparet och värdet för det mappade elementet är tillgängligt via den andra medlemmen i paret.

Exempel

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

hash_multimap::size

Anmärkning

Det här API:et är föråldrat. Alternativet är unordered_multimap-klass.

Returnerar antalet element i hash_multimap.

size_type size() const;

Returvärde

Den aktuella längden på hash_multimap.

Anmärkningar

Exempel

I följande exempel visas hur funktionen hash_multimap::size member används.

// hash_multimap_size.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
    using namespace std;
    using namespace stdext;
    hash_multimap<int, int> hm1, hm2;
    hash_multimap<int, int>::size_type i;
    typedef pair<int, int> Int_Pair;

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

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

The hash_multimap length is 1.
The hash_multimap length is now 2.

hash_multimap::size_type

Anmärkning

Det här API:et är föråldrat. Alternativet är unordered_multimap-klass.

En osignerad heltalstyp som räknar antalet element i en hash_multimap.

typedef list<typename _Traits::value_type, typename _Traits::allocator_type>::size_type size_type;

Anmärkningar

Exempel

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

hash_multimap::swap

Anmärkning

Det här API:et är föråldrat. Alternativet är unordered_multimap-klass.

Utbyter elementen i två hash_multimaps.

void swap(hash_multimap& right);

Parameterar

rätt
Den hash_multimap som tillhandahåller de element som ska bytas ut eller de hash_multimap vars element ska bytas ut mot hash_multimap.

Anmärkningar

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

Exempel

// hash_multimap_swap.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_multimap <int, int> hm1, hm2, hm3;
   hash_multimap <int, int>::iterator hm1_Iter;
   typedef pair <int, int> Int_Pair;

   hm1.insert ( Int_Pair ( 1, 10 ) );
   hm1.insert ( Int_Pair ( 2, 20 ) );
   hm1.insert ( Int_Pair ( 3, 30 ) );
   hm2.insert ( Int_Pair ( 10, 100 ) );
   hm2.insert ( Int_Pair ( 20, 200 ) );
   hm3.insert ( Int_Pair ( 30, 300 ) );

   cout << "The original hash_multimap hm1 is:";
   for ( hm1_Iter = hm1.begin( ); hm1_Iter != hm1.end( ); hm1_Iter++ )
      cout << " " << hm1_Iter -> second;
   cout   << "." << endl;

   // This is the member function version of swap
   hm1.swap( hm2 );

   cout << "After swapping with hm2, hash_multimap hm1 is:";
   for ( hm1_Iter = hm1.begin( ); hm1_Iter != hm1.end( ); hm1_Iter++ )
      cout << " " << hm1_Iter -> second;
   cout  << "." << endl;

   // This is the specialized template version of swap
   swap( hm1, hm3 );

   cout << "After swapping with hm3, hash_multimap hm1 is:";
   for ( hm1_Iter = hm1.begin( ); hm1_Iter != hm1.end( ); hm1_Iter++ )
      cout << " " << hm1_Iter -> second;
   cout   << "." << endl;
}

The original hash_multimap hm1 is: 10 20 30.
After swapping with hm2, hash_multimap hm1 is: 100 200.
After swapping with hm3, hash_multimap hm1 is: 300.

hash_multimap::upper_bound

Anmärkning

Det här API:et är föråldrat. Alternativet är unordered_multimap-klass.

Returnerar en iterator till det första elementet i en hash_multimap med en nyckel som är större än en angiven nyckel.

iterator upper_bound(const Key& key);

const_iterator upper_bound(const Key& key) const;

Parameterar

nyckel
Argumentnyckeln som ska jämföras med sorteringsnyckeln för ett element från hash_multimap som genomsöks.

Returvärde

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

Om returvärdet upper_bound för har tilldelats till ett const_iteratorkan hash_multimap-objektet inte ändras. Om returvärdet upper_bound för har tilldelats till ett iteratorkan hash_multimap-objektet ändras.

Anmärkningar

Exempel

// hash_multimap_upper_bound.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_multimap <int, int> hm1;
   hash_multimap <int, int> :: const_iterator hm1_AcIter, hm1_RcIter;
   typedef pair <int, int> Int_Pair;

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

   hm1_RcIter = hm1.upper_bound( 1 );
   cout << "The 1st element of hash_multimap hm1 with "
        << "a key greater than 1 is: "
        << hm1_RcIter -> second << "." << endl;

   hm1_RcIter = hm1.upper_bound( 2 );
   cout << "The first element of hash_multimap hm1\n"
        << "with a key greater than 2 is: "
        << hm1_RcIter -> second << "." << endl;

   // If no match is found for the key, end( ) is returned
   hm1_RcIter = hm1.lower_bound( 4 );

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

   // The element at a specific location in the hash_multimap can be
   // found using a dereferenced iterator addressing the location
   hm1_AcIter = hm1.begin( );
   hm1_RcIter = hm1.upper_bound( hm1_AcIter -> first );
   cout << "The first element of hm1 with a key greater than"
        << endl << "that of the initial element of hm1 is: "
        << hm1_RcIter -> second << "." << endl;
}

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

hash_multimap::value_comp

Anmärkning

Det här API:et är föråldrat. Alternativet är unordered_multimap-klass.

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

value_compare value_comp() const;

Returvärde

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

Anmärkningar

För en hash_multimap m, om två element e1 (k1,d1) och e2(k2, d2) är objekt av typen value_type, där k1 och k2 ä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

// hash_multimap_value_comp.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;

   hash_multimap <int, int, hash_compare<int, less<int>>> hm1;
   hash_multimap <int, int, hash_compare<int, less<int>>
      >::value_compare vc1 = hm1.value_comp( );
   hash_multimap <int,int>::iterator Iter1, Iter2;

   Iter1= hm1.insert ( hash_multimap <int, int> :: value_type ( 1, 10 ) );
   Iter2= hm1.insert ( hash_multimap <int, int> :: value_type ( 2, 5 ) );

   if( vc1( *Iter1, *Iter2 ) == 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( *Iter2, *Iter1 ) == 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;
   }
}

hash_multimap::value_type

Anmärkning

Det här API:et är föråldrat. Alternativet är unordered_multimap-klass.

En typ som representerar den typ av objekt som lagras i en hash_multimap.

typedef pair<const Key, Type> value_type;

Anmärkningar

value_type deklareras som parkonfigurerad<key_type, mapped_type> och inte parkoppling<key_type, mapped_type> eftersom nycklarna i en associativ container inte kan ändras med hjälp av en icke-konstanterande iterator eller referens.

Exempel

// hash_multimap_value_type.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

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

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

   // Compare another way to insert objects into a hash_multimap
   hm1.insert ( cInt2Int ( 2, 20 ) );

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

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

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

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

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

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

The key of first element in the hash_multimap is 1.
The data value of first element in the hash_multimap is 10.
The keys of the mapped elements are: 1 2.
The values of the mapped elements are: 10 20.

Se även

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

Dela via

hash_multimap-klass

Syntax

Parameterar

Anmärkningar

Konstruktörer

Typedefs

Medlemsfunktioner

Operatörer

Kravspecifikation

hash_multimap::allocator_type

Anmärkningar

Exempel

hash_multimap::begin

Returvärde

Anmärkningar

Exempel

hash_multimap::cbegin

Returvärde

Exempel

hash_multimap::cend

Returvärde

Anmärkningar

Exempel

hash_multimap::clear

Anmärkningar

Exempel

hash_multimap::const_iterator

Anmärkningar

Exempel

hash_multimap::const_pointer

Anmärkningar

hash_multimap::const_reference

Anmärkningar

Exempel

hash_multimap::const_reverse_iterator

Anmärkningar

Exempel

hash_multimap::count

Parameterar

Returvärde

Anmärkningar

Exempel

hash_multimap::crbegin

Returvärde

Anmärkningar

Exempel

hash_multimap::crend

Returvärde

Anmärkningar

Exempel

hash_multimap::d ifference_type

Anmärkningar

Exempel

hash_multimap::emplace

Parameterar

Returvärde

Anmärkningar

Exempel

hash_multimap::emplace_hint

Parameterar

Returvärde

Anmärkningar

Exempel

hash_multimap::empty

Returvärde

Anmärkningar

Exempel

hash_multimap::end

Returvärde

Anmärkningar

Exempel

hash_multimap::equal_range

Parameterar

Returvärde

Anmärkningar

Exempel

hash_multimap::erase

Parameterar

Returvärde