Notitie
Voor toegang tot deze pagina is autorisatie vereist. U kunt proberen u aan te melden of de directory te wijzigen.
Voor toegang tot deze pagina is autorisatie vereist. U kunt proberen de mappen te wijzigen.
Opmerking
Deze API is verouderd. Het alternatief is unordered_multimap Klasse.
De containerklasse hash_multimap is een uitbreiding van de C++-standaardbibliotheek en wordt gebruikt voor de opslag en het snel ophalen van gegevens uit een verzameling waarin elk element een paar is dat een sorteersleutel heeft waarvan de waarde niet uniek hoeft te zijn en een bijbehorende gegevenswaarde.
Syntaxis
template <class Key,
class Type,
class Traits=hash_compare <Key, less <Key>>,
class Allocator=allocator <pair <const Key, Type>>>
class hash_multimap
Parameterwaarden
Sleutel
Het sleutelgegevenstype dat moet worden opgeslagen in de hash_multimap.
Typ
Het gegevenstype element dat moet worden opgeslagen in de hash_multimap.
eigenschappen
Het type dat twee functieobjecten bevat, een van klasseeigenschappen die twee elementwaarden kunnen vergelijken als sorteersleutels om hun relatieve volgorde te bepalen en een hash-functie die een unaire predicaat sleutelwaarden van de elementen aan niet-ondertekende gehele getallen van het type size_tis. Dit argument is optioneel en de hash_compare<Key, less<Key>> standaardwaarde.
Allocator
Het type dat het opgeslagen allocatorobject vertegenwoordigt dat details bevat over de toewijzing en toewijzing van het geheugen van de hash_multimap. Dit argument is optioneel en de standaardwaarde is allocator<pair <const Key, Type>>.
Opmerkingen
De hash_multimap is:
Een associatieve container, die een container met variabele grootte ondersteunt die ondersteuning biedt voor het efficiënt ophalen van elementwaarden op basis van een gekoppelde sleutelwaarde.
Omkeerbaar, omdat het een bidirectionele iterator biedt voor toegang tot de elementen.
Gehasht, omdat de elementen zijn gegroepeerd in buckets op basis van de waarde van een hash-functie die is toegepast op de sleutelwaarden van de elementen.
Meerdere, omdat de elementen geen unieke sleutels hoeven te hebben, zodat één sleutelwaarde mogelijk veel elementgegevenswaarden eraan is gekoppeld.
Een koppelingskoppelingscontainer, omdat de elementwaarden verschillen van de sleutelwaarden.
Een klassesjabloon, omdat de functionaliteit die het biedt algemeen is en zo onafhankelijk is van het specifieke type gegevens dat is opgenomen als elementen of sleutels. De gegevenstypen die moeten worden gebruikt voor elementen en sleutels, worden in plaats daarvan opgegeven als parameters in de klassesjabloon, samen met de vergelijkingsfunctie en allocator.
Het belangrijkste voordeel van hashing over sorteren is een grotere efficiëntie; een geslaagde hashing voert invoegingen, verwijderingen en vindt deze in constante gemiddelde tijd in vergelijking met een tijd die evenredig is met de logaritme van het aantal elementen in de container voor sorteertechnieken. De waarde van een element in een hash_multimap, maar niet de bijbehorende sleutelwaarde, kan rechtstreeks worden gewijzigd. In plaats daarvan moeten sleutelwaarden die zijn gekoppeld aan oude elementen worden verwijderd en nieuwe sleutelwaarden die zijn gekoppeld aan nieuwe elementen die zijn ingevoegd.
De keuze van het containertype moet in het algemeen worden gebaseerd op het type zoeken en invoegen dat vereist is voor de toepassing. Gehashte associatieve containers zijn geoptimaliseerd voor de bewerkingen van opzoeken, invoegen en verwijderen. De lidfuncties die deze bewerkingen expliciet ondersteunen, zijn efficiënt wanneer ze worden gebruikt met een goed ontworpen hash-functie, waarbij ze worden uitgevoerd in een tijd die gemiddeld constant is en niet afhankelijk is van het aantal elementen in de container. Een goed ontworpen hash-functie produceert een uniforme verdeling van gehashte waarden en minimaliseert het aantal botsingen, waarbij een botsing wordt gezegd wanneer afzonderlijke sleutelwaarden worden toegewezen aan dezelfde gehashte waarde. In het ergste geval, met de slechtst mogelijke hash-functie, is het aantal bewerkingen evenredig met het aantal elementen in de reeks (lineaire tijd).
De hash_multimap moet de associatieve container van keuze zijn wanneer aan de voorwaarden voor het koppelen van de waarden aan hun sleutels wordt voldaan door de toepassing. Een model voor dit type structuur is een geordende lijst met sleutelwoorden met gekoppelde tekenreekswaarden die definities bieden, waarbij de woorden niet altijd uniek zijn gedefinieerd. Als in plaats daarvan de trefwoorden uniek zijn gedefinieerd, zodat sleutels uniek waren, zou een hash_map de gewenste container zijn. Als daarentegen alleen de lijst met woorden werd opgeslagen, zou een hash_set de juiste container zijn. Als meerdere exemplaren van de woorden zijn toegestaan, is een hash_multiset de juiste containerstructuur.
De hash_multimap ordet de volgorde die wordt beheerd door een opgeslagen hash-object Traits van het type value_compare aan te roepen. Dit opgeslagen object kan worden geopend door de lidfunctie aan te roepen key_comp. Een dergelijk functieobject moet zich hetzelfde gedragen als een object van klasse hash_compare<Key, less<Key>>. Met name voor alle waarden Key van het type Keygeeft de aanroep Traits (Key) een verdeling van de waarden van het type size_t.
Over het algemeen moeten de elementen slechts kleiner zijn dan vergelijkbaar zijn om deze volgorde vast te stellen, zodat, gezien twee elementen, kan worden vastgesteld dat ze gelijkwaardig zijn (in de zin dat geen van beide minder is dan de andere) of dat de ene niet kleiner is dan de andere. Dit resulteert in een volgorde tussen de niet-equivalente elementen. Op een technischere opmerking is de vergelijkingsfunctie een binair predicaat dat een strikte zwakke volgorde veroorzaakt in de standaard wiskundige zin. Een binair predicaat f(x, y) is een functieobject met twee argumentobjecten x en y een retourwaarde van true of false. Een orde die wordt opgelegd aan een hash_multimap is een strikte zwakke orde als het binaire predicaat irreflexieve, antisymmetrische en transitieve is en als gelijkwaardigheid transitief is, waarbij twee objecten x en y gedefinieerd zijn als gelijkwaardig wanneer zowel f(x, y) als f(y, x) zijn false. Als de sterkere voorwaarde van gelijkheid tussen sleutels dat van gelijkwaardigheid vervangt, wordt de volgorde in totaal (in de zin dat alle elementen met betrekking tot elkaar worden gerangschikt) en zijn de overeenkomende sleutels niet meer van elkaar te onderscheiden.
De werkelijke volgorde van elementen in de gecontroleerde volgorde is afhankelijk van de hash-functie, de volgordefunctie en de huidige grootte van de hash-tabel die is opgeslagen in het containerobject. U kunt de huidige grootte van de hash-tabel niet bepalen, dus u kunt de volgorde van elementen in de gecontroleerde volgorde niet voorspellen. Als u elementen invoegt, worden er geen iterators gebruikt en worden alleen de iterators die specifiek naar de verwijderde elementen hebben verwezen, ongeldig.
De iterator die wordt geleverd door de hash_multimap-klasse is een bidirectionele iterator, maar de functies van het klasselid invoegen en hash_multimap versies hebben die als sjabloonparameters een zwakkere invoer-iterator gebruiken, waarvan de functionaliteitsvereisten minimaal zijn dan die worden gegarandeerd door de klasse van bidirectionele iterators. De verschillende iteratorconcepten vormen een familie gerelateerd aan verfijningen in hun functionaliteit. Elk iterator-concept heeft een eigen hash_multimap van vereisten en de algoritmen die ermee werken, moeten hun veronderstellingen beperken tot de vereisten van dat type iterator. Er kan worden aangenomen dat een invoer-iterator kan worden gededucteerd om naar een bepaald object te verwijzen en dat het kan worden verhoogd naar de volgende iterator in de reeks. Dit is een minimale hash_multimap functionaliteit, maar het is voldoende om zinvol te kunnen praten over een reeks iterators [First, Last) in de context van de lidfuncties.
Constructeurs
| Constructeur | Beschrijving |
|---|---|
| hash_multimap | Hiermee maakt u een lijst met een specifieke grootte of met elementen van een specifieke waarde of met een specifieke allocator of als kopie van een andere hash_multimapwaarde. |
Typedefs
| Typenaam | Beschrijving |
|---|---|
| allocator_type | Een type dat de allocator-klasse voor het hash_multimap-object vertegenwoordigt. |
| const_iterator | Een type dat een bidirectionele iterator biedt die een const element in de hash_multimap. |
| const_pointer | Een type dat een aanwijzer naar een const element in een hash_multimap. |
| const_reference | Een type dat een verwijzing biedt naar een const element dat is opgeslagen in een hash_multimap voor het lezen en uitvoeren van const bewerkingen. |
| const_reverse_iterator | Een type dat een bidirectionele iterator biedt die elk const element in de hash_multimap. |
| difference_type | Een ondertekend geheel getal dat kan worden gebruikt om het aantal elementen van een hash_multimap in een bereik weer te geven tussen elementen waarnaar wordt verwezen door iterators. |
| Iterator | Een type dat een bidirectionele iterator biedt die elk element in een hash_multimap. |
| key_compare | Een type dat een functieobject biedt waarmee twee sorteersleutels kunnen worden vergeleken om de relatieve volgorde van twee elementen in de hash_multimap. |
| key_type | Een type dat het sorteersleutelobject beschrijft dat elk element van de hash_multimap. |
| mapped_type | Een type dat het gegevenstype vertegenwoordigt dat is opgeslagen in een hash_multimap. |
| aanwijzer | Een type dat een aanwijzer naar een element in een hash_multimapbiedt. |
| referentie | Een type dat een verwijzing biedt naar een element dat is opgeslagen in een hash_multimap. |
| reverse_iterator | Een type dat een bidirectionele iterator biedt waarmee een element in een omgekeerde weergave kan worden gelezen of gewijzigd hash_multimap. |
| size_type | Een niet-ondertekend geheel getaltype dat het aantal elementen in een hash_multimap. |
| value_type | Een type dat een functieobject biedt waarmee twee elementen kunnen worden vergeleken als sorteersleutels om de relatieve volgorde in de hash_multimap. |
Functies voor leden
| Lid, functie | Beschrijving |
|---|---|
| beginnen | Retourneert een iterator die het eerste element in de hash_multimapadresseert. |
| cbegin | Retourneert een const iterator die het eerste element in de hash_multimap. |
| cend | Retourneert een const iterator die de locatie adresseert die het laatste element in een hash_multimap. |
| wissen | Hiermee worden alle elementen van een hash_multimapgewist. |
| aantal | Retourneert het aantal elementen in een hash_multimap wiens sleutel overeenkomt met een door een parameter opgegeven sleutel. |
| crbegin | Retourneert een const iterator die het eerste element in een omgekeerd element aanpakt hash_multimap. |
| crend | Retourneert een const iterator waarmee de locatie wordt opgelost die het laatste element in een omgekeerde hash_multimaplocatie slaagt. |
| emplace | Hiermee voegt u een element in hash_multimapeen . |
| emplace_hint | Hiermee voegt u een element in hash_multimapeen , met een plaatsingshint. |
| leeg | Test of een hash_multimap leeg is. |
| einde | Retourneert een iterator waarmee de locatie wordt opgelost die het laatste element in een hash_multimapslaagt. |
| equal_range | Retourneert een iterator waarmee de locatie wordt opgelost die het laatste element in een hash_multimapslaagt. |
| wissen | Hiermee verwijdert u een element of een reeks elementen in een hash_multimap opgegeven positie |
| vinden | Retourneert een iterator die de locatie van een element in een hash_multimap dat een sleutel heeft die gelijk is aan een opgegeven sleutel. |
| get_allocator | Retourneert een kopie van het allocator object dat wordt gebruikt om de hash_multimap. |
| invoegen | Hiermee voegt u een element of een reeks elementen in de hash_multimap opgegeven positie in. |
| key_comp | Hiermee wordt een kopie opgehaald van het vergelijkingsobject dat wordt gebruikt om sleutels in een hash_multimap. |
| lower_bound | Retourneert een iterator naar het eerste element in een hash_multimap element met een sleutelwaarde die gelijk is aan of groter is dan die van een opgegeven sleutel. |
| max_size | Geeft als resultaat de maximale lengte van de hash_multimap. |
| rbegin | Retourneert een iterator die het eerste element in een omgekeerde aanpak aanpakt hash_multimap. |
| rend | Retourneert een iterator waarmee de locatie wordt opgelost waarop het laatste element in een omgekeerde hash_multimapis geslaagd. |
| grootte | Hiermee geeft u een nieuwe grootte voor een hash_multimap. |
| wisselen | Uitwisseling van de elementen van twee hash_multimaps. |
| upper_bound | Retourneert een iterator naar het eerste element in een hash_multimap element met een sleutelwaarde die groter is dan die van een opgegeven sleutel. |
| value_comp | Hiermee wordt een kopie opgehaald van het vergelijkingsobject dat wordt gebruikt om elementwaarden in een hash_multimap. |
Bedieners
| Operateur | Beschrijving |
|---|---|
| hash_multimap::operator= | Vervangt de elementen van een hash_multimap bestand door een kopie van een andere hash_multimap. |
Behoeften
Rubriek:<hash_map>
Naamruimte: stdext
hash_multimap::allocator_type
Opmerking
Deze API is verouderd. Het alternatief is unordered_multimap Klasse.
Een type dat de allocatorklasse vertegenwoordigt voor het hash_multimap-object.
typedef list<typename Traits::value_type, typename Traits::allocator_type>::allocator_type allocator_type;
Opmerkingen
allocator_type is een synoniem voor de sjabloonparameter Allocator.
Zie de sectie Opmerkingen van het Allocator voor meer informatie.
Voorbeeld
Zie het voorbeeld voor get_allocator voor een voorbeeld met behulp van allocator_type.
hash_multimap::begin
Opmerking
Deze API is verouderd. Het alternatief is unordered_multimap Klasse.
Retourneert een iterator die het eerste element in de hash_multimap adresseert.
const_iterator begin() const;
iterator begin();
Retourwaarde
Een bidirectionele iterator die het eerste element in de hash_multimap of de locatie slaagt in een lege hash_multimap.
Opmerkingen
Als de retourwaarde is begin toegewezen aan een const_iterator, kunnen de elementen in het hash_multimap object niet worden gewijzigd. Als de retourwaarde begin is toegewezen aan een iterator, kunnen de elementen in het hash_multimap-object worden gewijzigd.
Voorbeeld
// 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
Opmerking
Deze API is verouderd. Het alternatief is unordered_multimap Klasse.
Retourneert een const iterator die het eerste element in de hash_multimap aanpakt.
const_iterator cbegin() const;
Retourwaarde
Een const bidirectionele iterator die het eerste element in de hash_multimap of de locatie slaagt in een lege hash_multimap.
Voorbeeld
// 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
Opmerking
Deze API is verouderd. Het alternatief is unordered_multimap Klasse.
Retourneert een const iterator waarmee de locatie wordt opgelost die het laatste element in een hash_multimap slaagt.
const_iterator cend() const;
Retourwaarde
Een const bidirectionele iterator die de locatie slaagt na het laatste element in een hash_multimap. Als de hash_multimap leeg is, hash_multimap::cend == hash_multimap::begin.
Opmerkingen
cend wordt gebruikt om te testen of een iterator het einde van de hash_multimap heeft bereikt.
De waarde die wordt geretourneerd door cend mag niet worden afgetrokken.
Voorbeeld
// 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
Opmerking
Deze API is verouderd. Het alternatief is unordered_multimap Klasse.
Hiermee worden alle elementen van een hash_multimap gewist.
void clear();
Voorbeeld
In het volgende voorbeeld ziet u het gebruik van de functie hash_multimap::clear member.
// 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
Opmerking
Deze API is verouderd. Het alternatief is unordered_multimap Klasse.
Een type dat een bidirectionele iterator biedt waarmee een const element in de hash_multimap kan worden gelezen.
typedef list<typename Traits::value_type, typename Traits::allocator_type>::const_iterator const_iterator;
Opmerkingen
Een type const_iterator kan niet worden gebruikt om de waarde van een element te wijzigen.
De const_iterator door hash_multimap gedefinieerde objecten van value_type, die van het type pair<const Key, Type>zijn. De waarde van de sleutel is beschikbaar via het eerste lidpaar en de waarde van het toegewezen element is beschikbaar via het tweede lid van het paar.
Als u een verwijzing naar een const_iteratorcIter element in een hash_multimap wilt deducteren, gebruikt u de -> operator.
Als u toegang wilt krijgen tot de waarde van de sleutel voor het element, gebruikt cIter->firstu , wat gelijk is aan (*cIter).first. Als u toegang wilt krijgen tot de waarde van de toegewezen datum voor het element, gebruikt cIter->secondu , wat gelijk is aan (*cIter).second.
Voorbeeld
Zie het voorbeeld voor het begin van een voorbeeld met behulp van const_iterator.
hash_multimap::const_pointer
Opmerking
Deze API is verouderd. Het alternatief is unordered_multimap Klasse.
Een type dat een aanwijzer biedt naar een const element in een hash_multimap.
typedef list<typename _Traits::value_type, typename _Traits::allocator_type>::const_pointer const_pointer;
Opmerkingen
Een type const_pointer kan niet worden gebruikt om de waarde van een element te wijzigen.
In de meeste gevallen moet een iterator worden gebruikt om toegang te krijgen tot de elementen in een hash_multimap-object.
hash_multimap::const_reference
Opmerking
Deze API is verouderd. Het alternatief is unordered_multimap Klasse.
Een type dat een verwijzing biedt naar een const element dat is opgeslagen in een hash_multimap voor het lezen en uitvoeren van bewerkingen const .
typedef list<typename _Traits::value_type, typename _Traits::allocator_type>::const_reference const_reference;
Voorbeeld
// 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
Opmerking
Deze API is verouderd. Het alternatief is unordered_multimap Klasse.
Een type dat een bidirectionele iterator biedt die elk const element in de hash_multimap kan lezen.
typedef list<typename Traits::value_type, typename Traits::allocator_type>::const_reverse_iterator const_reverse_iterator;
Opmerkingen
Een type const_reverse_iterator kan de waarde van een element niet wijzigen en wordt gebruikt om de hash_multimap omgekeerd te doorlopen.
De const_reverse_iterator door hash_multimap gedefinieerde objecten van value_type, die van het type pair<const Key, Type>zijn, waarvan het eerste lid de sleutel is van het element en waarvan het tweede lid de toegewezen datum is die door het element wordt vastgehouden.
Als u een verwijzing naar een const_reverse_iteratorcrIter element in een hash_multimap wilt deducteren, gebruikt u de -> operator.
Als u toegang wilt krijgen tot de waarde van de sleutel voor het element, gebruikt crIter->firstu , wat gelijk is aan (*crIter).first. Als u toegang wilt krijgen tot de waarde van de toegewezen datum voor het element, gebruikt crIter->secondu , wat gelijk is aan (*crIter).second.
Voorbeeld
Zie het voorbeeld voor rend voor een voorbeeld van het declareren en gebruiken van de const_reverse_iterator.
hash_multimap::count
Opmerking
Deze API is verouderd. Het alternatief is unordered_multimap Klasse.
Retourneert het aantal elementen in een hash_multimap waarvan de sleutel overeenkomt met een door een parameter opgegeven sleutel.
size_type count(const Key& key) const;
Parameterwaarden
sleutel
De sleutel van de elementen die moeten worden vergeleken met de hash_multimap.
Retourwaarde
1 als de hash_multimap een element bevat waarvan de sorteersleutel overeenkomt met de parametersleutel; 0 als de hash_multimap geen element met een overeenkomende sleutel bevat.
Opmerkingen
De lidfunctie retourneert het aantal elementen in het bereik
[lower_bound (key), upper_bound (key)
die een sleutelwaardesleutel hebben.
Voorbeeld
In het volgende voorbeeld ziet u het gebruik van de functie 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
Opmerking
Deze API is verouderd. Het alternatief is unordered_multimap Klasse.
Retourneert een const iterator die het eerste element in een omgekeerde hash_multimap aanpakt.
const_reverse_iterator crbegin() const;
Retourwaarde
Een omgekeerde bidirectionele iterator die het eerste element in een omgekeerde hash_multimap aanpakt of het aanpakken van wat het laatste element in de niet-omgedraaide hash_multimapelementen was geweest.
Opmerkingen
crbegin wordt gebruikt met een omgekeerde hash_multimap net zoals hash_multimap:::begin wordt gebruikt met een hash_multimap.
Met de retourwaarde van crbeginkan het hash_multimap object niet worden gewijzigd.
crbegin kan worden gebruikt om een hash_multimap achteruit te doorlopen.
Voorbeeld
// 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
Opmerking
Deze API is verouderd. Het alternatief is unordered_multimap Klasse.
Retourneert een const iterator die de locatie adresseert die het laatste element in een omgekeerde hash_multimap slaagt.
const_reverse_iterator crend() const;
Retourwaarde
Een omgekeerde bidirectionele iterator die de locatie afhandelt die het laatste element in een omgekeerde hash_multimap (de locatie die voorafging aan het eerste element in de niet-omgedraaide hash_multimap).
Opmerkingen
crend wordt gebruikt met een omgekeerde hash_multimap net zoals hash_multimap::end wordt gebruikt met een hash_multimap.
Met de retourwaarde van crendkan het hash_multimap object niet worden gewijzigd.
crend kan worden gebruikt om te testen of een omgekeerde iterator het einde van de hash_multimap heeft bereikt.
De waarde die wordt geretourneerd door crend mag niet worden afgetrokken.
Voorbeeld
// 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 deductietype
Opmerking
Deze API is verouderd. Het alternatief is unordered_multimap Klasse.
Een ondertekend geheel getaltype dat kan worden gebruikt om het aantal elementen van een hash_multimap weer te geven in een bereik tussen elementen waarnaar wordt verwezen door iterators.
typedef list<typename _Traits::value_type, typename _Traits::allocator_type>::difference_type difference_type;
Opmerkingen
Dit difference_type is het type dat wordt geretourneerd bij het aftrekken of verhogen van iterators van de container. Het difference_type wordt meestal gebruikt om het aantal elementen in het bereik [ eerste, laatste) tussen de iterators first en last, omvat het element dat is verwezen door first en het bereik van elementen tot, maar niet inclusief, het element dat door .last
Houd er rekening mee dat difference_type hoewel deze beschikbaar is voor alle iterators die voldoen aan de vereisten van een invoer-iterator, die de klasse van bidirectionele iterators omvat die worden ondersteund door omkeerbare containers zoals set, wordt aftrekken tussen iterators alleen ondersteund door iterators voor willekeurige toegang die wordt geleverd door een container met willekeurige toegang, zoals vector.
Voorbeeld
// 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
Opmerking
Deze API is verouderd. Het alternatief is unordered_multimap Klasse.
Hiermee voegt u een element in een hash_multimap.
template <class ValTy>
iterator emplace(ValTy&& val);
Parameterwaarden
val-
De waarde die wordt gebruikt om een element te verplaatsen dat in de hash_multimap moet worden ingevoegd.
Retourwaarde
De emplace lidfunctie retourneert een iterator die verwijst naar de positie waar het nieuwe element is ingevoegd.
Opmerkingen
De hash_multimap::value_type van een element is een paar, zodat de waarde van een element een geordende paar is met het eerste onderdeel dat gelijk is aan de sleutelwaarde en het tweede onderdeel gelijk is aan de gegevenswaarde van het element.
Voorbeeld
// 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
Opmerking
Deze API is verouderd. Het alternatief is unordered_multimap Klasse.
Hiermee voegt u een element in een hash_multimap in, met een plaatsingshint.
template <class ValTy>
iterator emplace_hint(
const_iterator _Where,
ValTy&& val);
Parameterwaarden
val-
De waarde die wordt gebruikt om een element te verplaatsen dat in de hash_multimap moet worden ingevoegd, tenzij het hash_multimap element al bevat (of, meer in het algemeen, een element waarvan de sleutel gelijkwaardig is gerangschikt).
_Waar
Een hint met betrekking tot de plaats waar moet worden gezocht naar het juiste invoegpunt.
Retourwaarde
De functie hash_multimap::emplace lid retourneert een iterator die verwijst naar de positie waar het nieuwe element is ingevoegd in de hash_multimap.
Opmerkingen
De hash_multimap::value_type van een element is een paar, zodat de waarde van een element een geordende paar is met het eerste onderdeel dat gelijk is aan de sleutelwaarde en het tweede onderdeel gelijk is aan de gegevenswaarde van het element.
Invoeging kan optreden in afgeschreven constante tijd, in plaats van logaritmische tijd, als de invoegpositie onmiddellijk volgt _Where.
Voorbeeld
// 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
Opmerking
Deze API is verouderd. Het alternatief is unordered_multimap Klasse.
Test of een hash_multimap leeg is.
bool empty() const;
Retourwaarde
true als de hash_multimap leeg is; false als de hash_multimap geenmpty is.
Voorbeeld
// 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
Opmerking
Deze API is verouderd. Het alternatief is unordered_multimap Klasse.
Retourneert een iterator waarmee de locatie wordt opgelost die het laatste element in een hash_multimap slaagt.
const_iterator end() const;
iterator end();
Retourwaarde
Een bidirectionele iterator waarmee de locatie wordt opgelost die het laatste element in een hash_multimap slaagt. Als de hash_multimap leeg is, hash_multimap::end == hash_multimap::begin.
Opmerkingen
end wordt gebruikt om te testen of een iterator het einde van de hash_multimap heeft bereikt.
De waarde die wordt geretourneerd door end mag niet worden afgetrokken.
Voorbeeld
// 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
Opmerking
Deze API is verouderd. Het alternatief is unordered_multimap Klasse.
Retourneert respectievelijk een paar iterators naar het eerste element in een hash_multimap met een sleutel die groter is dan een opgegeven sleutel en aan het eerste element in de hash_multimap met een sleutel die gelijk is aan of groter is dan de sleutel.
pair <const_iterator, const_iterator> equal_range (const Key& key) const;
pair <iterator, iterator> equal_range (const Key& key);
Parameterwaarden
sleutel
De argumentsleutel die moet worden vergeleken met de sorteersleutel van een element uit de hash_multimap die wordt doorzocht.
Retourwaarde
Een paar iterators zodanig dat de eerste de lower_bound van de sleutel is en de tweede is de upper_bound van de sleutel.
Als u toegang wilt krijgen tot de eerste iterator van een paar pr dat wordt geretourneerd door de lidfunctie, gebruikt u pr.
gebruik eerst *(pr) om de ondergrens-iterator te deducteren. eerst). Als u toegang wilt krijgen tot de tweede iterator van een paar pr dat wordt geretourneerd door de lidfunctie, gebruikt u pr.
ten tweede en om de bovengrens-iterator te deducteren, gebruikt u *(pr. seconde).
Voorbeeld
// 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::gum
Opmerking
Deze API is verouderd. Het alternatief is unordered_multimap Klasse.
Hiermee verwijdert u een element of een reeks elementen in een hash_multimap uit opgegeven posities of verwijdert u elementen die overeenkomen met een opgegeven sleutel.
iterator erase(iterator _Where);
iterator erase(iterator first, iterator last);
size_type erase(const key_type& key);
Parameterwaarden
_Waar
De positie van het element dat moet worden verwijderd uit de hash_multimap.
eerste
Positie van het eerste element dat uit de hash_multimap is verwijderd.
laatste
Positie vlak voorbij het laatste element dat uit de hash_multimap is verwijderd.
sleutel
De sleutel van de elementen die uit de hash_multimap moeten worden verwijderd.
Retourwaarde
Voor de eerste twee lidfuncties, een bidirectionele iterator die het eerste element aanwijst dat buiten alle elementen blijft verwijderd, of een aanwijzer naar het einde van de hash_multimap als er geen dergelijk element bestaat.
Voor de functie derde lid wordt het aantal elementen geretourneerd dat uit de hash_multimap is verwijderd.
Opmerkingen
De lidfuncties genereren nooit een uitzondering.
Voorbeeld
In het volgende voorbeeld ziet u het gebruik van de functie hash_multimap::gumlid.
// 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
Opmerking
Deze API is verouderd. Het alternatief is unordered_multimap Klasse.
Retourneert een iterator die de eerste locatie van een element in een hash_multimap heeft die een sleutel heeft die gelijk is aan een opgegeven sleutel.
iterator find(const Key& key);
const_iterator find(const Key& key) const;
Parameterwaarden
sleutel
De sleutel die moet worden vergeleken met de sorteersleutel van een element uit de hash_multimap die wordt doorzocht.
Retourwaarde
Een iterator die de eerste locatie van een element met een opgegeven sleutel adresseert, of de locatie die het laatste element in de hash_multimap slaagt als er geen overeenkomst voor de sleutel wordt gevonden.
Opmerkingen
De lidfunctie retourneert een iterator die een element in de hash_multimap aangeeft waarvan de sorteersleutel de argumentsleutel is equivalent onder een binair predicaat dat een volgorde veroorzaakt op basis van een minder dan vergelijkbaarheidsrelatie.
Als de retourwaarde find is toegewezen aan een const_iterator, kan het hash_multimap object niet worden gewijzigd. Als de retourwaarde find is toegewezen aan een iterator, kan het hash_multimap object worden gewijzigd.
Voorbeeld
// 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
Opmerking
Deze API is verouderd. Het alternatief is unordered_multimap Klasse.
Retourneert een kopie van het allocatorobject dat wordt gebruikt om de hash_multimap samen te stellen.
Allocator get_allocator() const;
Retourwaarde
De allocator die door de hash_multimap wordt gebruikt.
Opmerkingen
Toewijzingen voor de hash_multimap-klasse geven aan hoe de klasse opslag beheert. De standaard-toewijzingen die worden geleverd met C++ Standard Library-containerklassen zijn voldoende voor de meeste programmeerbehoeften. Schrijven en gebruiken van uw eigen allocatorklasse is een geavanceerd C++-onderwerp.
Voorbeeld
// 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
Opmerking
Deze API is verouderd. Het alternatief is unordered_multimap Klasse.
Hiermee wordt een hash_multimap gemaakt die leeg is of een kopie is van alle of een deel van een andere 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);
Parameterwaarden
Al
De opslagtoedeelingsklasse die moet worden gebruikt voor dit hash_multimap-object, dat standaard wordt gebruikt Allocator.
Comp
De vergelijkingsfunctie van het type const Traits dat wordt gebruikt om de elementen in de kaart te ordenen, die standaard wordt gebruikt Traits.
Rechts
De kaart waarvan de samengestelde set een kopie is.
Eerste
De positie van het eerste element in het bereik van elementen dat moet worden gekopieerd.
laatste
De positie van het eerste element buiten het bereik van elementen dat moet worden gekopieerd.
IList
De initializer_list waaruit u wilt kopiëren.
Opmerkingen
Alle constructors slaan een type allocatorobject op dat geheugenopslag voor de hash_multimap beheert en die later kan worden geretourneerd door get_allocator aan te roepen. De parameter allocator wordt vaak weggelaten in de klassedeclaraties en voorverwerkingsmacro's worden gebruikt om alternatieve allocators te vervangen.
Alle constructors initialiseren hun hash_multimap.
Alle constructors slaan een functieobject van het type Traits op dat wordt gebruikt om een volgorde tot stand te brengen tussen de sleutels van de hash_multimap en kunnen later worden geretourneerd door key_comp aan te roepen.
De eerste drie constructors geven een lege initiële hash_multimap op; de tweede geeft het type vergelijkingsfunctie (Comp) aan dat moet worden gebruikt bij het vaststellen van de volgorde van de elementen en de derde geeft expliciet het allocatortype (_Al) aan dat moet worden gebruikt. Het trefwoord explicit onderdrukt bepaalde soorten automatische typeconversie.
De vierde constructor geeft een kopie van de hash_multimap Right.
De volgende drie constructors kopiëren het bereik First, Last) van een kaart met toenemende explicietheid bij het opgeven van het type vergelijkingsfunctie van klasse Traits en allocator.
De achtste constructor verplaatst de hash_multimap Right.
De laatste drie constructors gebruiken een initializer_list.
hash_multimap::insert
Opmerking
Deze API is verouderd. Het alternatief is unordered_multimap Klasse.
Hiermee voegt u een element of een reeks elementen in een hash_multimap in.
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);
Parameterwaarden
Val
De waarde van een element dat in de hash_multimap moet worden ingevoegd, tenzij het al dat element bevat, of meer in het algemeen, tenzij het al een element bevat waarvan de sleutel gelijkwaardig is gerangschikt.
Waar
Een hint over waar moet worden gezocht naar het juiste invoegpunt.
Eerste
De positie van het eerste element dat moet worden gekopieerd van een kaart.
laatste
De positie net buiten het laatste element dat moet worden gekopieerd van een kaart.
Retourwaarde
De eerste twee insert lidfuncties retourneren een iterator die verwijst naar de positie waar het nieuwe element is ingevoegd.
De functie derde lid gebruikt een initializer_list om de elementen in te voegen.
Met de vierde lidfunctie wordt de volgorde van elementwaarden ingevoegd in een kaart die overeenkomt met elk element dat wordt geadresseerd door een iterator in het bereik [First, Last) van een opgegeven set.
De laatste twee insert lidfuncties gedragen zich hetzelfde als de eerste twee, behalve dat ze de ingevoegde waarde verplaatsen.
Opmerkingen
De value_type van een element is een paar, zodat de waarde van een element een geordende paar is waarin het eerste onderdeel gelijk is aan de sleutelwaarde en het tweede onderdeel gelijk is aan de gegevenswaarde van het element.
Invoeging kan optreden in afgeschreven constante tijd voor de hintversie van insert, in plaats van logaritmische tijd, als de invoegpositie onmiddellijk volgt op Where.
hash_multimap::iterator
Opmerking
Deze API is verouderd. Het alternatief is unordered_multimap Klasse.
Een type dat een bidirectionele iterator biedt waarmee elk element in een hash_multimap kan worden gelezen of gewijzigd.
typedef list<typename Traits::value_type, typename Traits::allocator_type>::iterator iterator;
Opmerkingen
De iterator gedefinieerde door hash_multimap verwijst naar objecten van value_type, die van het type pair<const Key, Type>, waarvan het eerste lid de sleutel is van het element en waarvan het tweede lid de toegewezen datum is die door het element wordt vastgehouden.
Gebruik de operator om een iterator met de Iter naam -> te deducteren die verwijst naar een element in een hash_multimap.
Als u toegang wilt krijgen tot de waarde van de sleutel voor het element, gebruikt Iter->firstu , wat gelijk is aan (*Iter).first. Als u toegang wilt krijgen tot de waarde van de toegewezen datum voor het element, gebruikt Iter->secondu , wat gelijk is aan (*Iter).first.
Een type iterator kan worden gebruikt om de waarde van een element te wijzigen.
Voorbeeld
Zie het voorbeeld voor het begin van een voorbeeld van het declareren en gebruiken iteratorvan .
hash_multimap::key_comp
Opmerking
Deze API is verouderd. Het alternatief is unordered_multimap Klasse.
Hiermee wordt een kopie opgehaald van het vergelijkingsobject dat wordt gebruikt om sleutels in een hash_multimap te ordenen.
key_compare key_comp() const;
Retourwaarde
Retourneert het functieobject dat een hash_multimap gebruikt om de elementen te ordenen.
Opmerkingen
Het opgeslagen object definieert de lidfunctie
bool operator( const Key& left, const Key& right );
die retourneert true als left deze voorafgaat en niet gelijk is aan right in de sorteervolgorde.
Voorbeeld
// 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
Opmerking
Deze API is verouderd. Het alternatief is unordered_multimap Klasse.
Een type dat een functieobject biedt waarmee twee sorteersleutels kunnen worden vergeleken om de relatieve volgorde van twee elementen in de hash_multimap te bepalen.
typedef Traits key_compare;
Opmerkingen
key_compare is een synoniem voor de sjabloonparameter Traits.
Zie het onderwerp hash_multimap Klas voor meer informatie over eigenschappen.
Voorbeeld
Zie het voorbeeld voor key_comp voor een voorbeeld van het declareren en gebruiken key_comparevan .
hash_multimap::key_type
Opmerking
Deze API is verouderd. Het alternatief is unordered_multimap Klasse.
Een type dat het sorteersleutelobject beschrijft dat elk element van de hash_multimap vormt.
typedef Key key_type;
Opmerkingen
key_type is een synoniem voor de parametersleutel van de sjabloon.
Zie de sectie Opmerkingen van het onderwerp hash_multimap Klas voor meer informatie over Key.
Voorbeeld
Zie het voorbeeld voor value_type voor een voorbeeld van het declareren en gebruiken key_comparevan .
hash_multimap::lower_bound
Opmerking
Deze API is verouderd. Het alternatief is unordered_multimap Klasse.
Hiermee wordt een iterator geretourneerd naar het eerste element in een hash_multimap met een sleutel die gelijk is aan of groter is dan een opgegeven sleutel.
iterator lower_bound(const Key& key);
const_iterator lower_bound(const Key& key) const;
Parameterwaarden
sleutel
De argumentsleutel die moet worden vergeleken met de sorteersleutel van een element uit de hash_multimap die wordt doorzocht.
Retourwaarde
Een iterator of const_iterator die de locatie van een element in een hash_multimap adresseert met een sleutel die gelijk is aan of groter is dan de argumentsleutel, of die de locatie adresseert die het laatste element in de hash_multimap slaagt als er geen overeenkomst voor de sleutel wordt gevonden.
Als de retourwaarde lower_bound is toegewezen aan een const_iterator, kan het hash_multimap object niet worden gewijzigd. Als de retourwaarde lower_bound is toegewezen aan een iterator, kan het hash_multimap object worden gewijzigd.
Voorbeeld
// 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
Opmerking
Deze API is verouderd. Het alternatief is unordered_multimap Klasse.
Een type dat het gegevenstype vertegenwoordigt dat is opgeslagen in een hash_multimap.
typedef Type mapped_type;
Opmerkingen
mapped_typeis een synoniem voor het sjabloonparametertype.
Zie het onderwerp hash_multimap Klasse voor meer informatie over Type.
Voorbeeld
Zie het voorbeeld voor value_type voor een voorbeeld van het declareren en gebruiken key_typevan .
hash_multimap::max_size
Opmerking
Deze API is verouderd. Het alternatief is unordered_multimap Klasse.
Retourneert de maximale lengte van de hash_multimap.
size_type max_size() const;
Retourwaarde
De maximale lengte van de hash_multimap.
Voorbeeld
// 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=
Opmerking
Deze API is verouderd. Het alternatief is unordered_multimap Klasse.
Vervangt de elementen van de hash_multimap door een kopie van een andere hash_multimap.
hash_multimap& operator=(const hash_multimap& right);
hash_multimap& operator=(hash_multimap&& right);
Parameterwaarden
rechts
De hash_multimap worden gekopieerd naar de hash_multimap.
Opmerkingen
Na het wissen van bestaande elementen in een hash_multimap, kopieert operator= of verplaatst u de inhoud van rechts naar de hash_multimap.
Voorbeeld
// 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
Opmerking
Deze API is verouderd. Het alternatief is unordered_multimap Klasse.
Een type dat een aanwijzer naar een element in een hash_multimap biedt.
typedef list<typename _Traits::value_type, typename _Traits::allocator_type>::pointer pointer;
Opmerkingen
Een type pointer kan worden gebruikt om de waarde van een element te wijzigen.
In de meeste gevallen moet een iterator worden gebruikt om toegang te krijgen tot de elementen in een hash_multimap-object.
hash_multimap::rbegin
Opmerking
Deze API is verouderd. Het alternatief is unordered_multimap Klasse.
Retourneert een iterator die het eerste element in een omgekeerde hash_multimap adresseert.
const_reverse_iterator rbegin() const;
reverse_iterator rbegin();
Retourwaarde
Een omgekeerde bidirectionele iterator die het eerste element in een omgekeerde hash_multimap adresseren of het aanpakken van wat het laatste element in de niet-omgedraaide hash_multimap was geweest.
Opmerkingen
rbegin wordt gebruikt met een omgekeerde hash_multimap net zoals het begin wordt gebruikt met een hash_multimap.
Als de retourwaarde rbegin is toegewezen aan een const_reverse_iterator, kan het hash_multimap object niet worden gewijzigd. Als de retourwaarde rbegin is toegewezen aan een reverse_iterator, kan het hash_multimap object worden gewijzigd.
rbegin kan worden gebruikt om een hash_multimap achteruit te doorlopen.
Voorbeeld
// 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
Opmerking
Deze API is verouderd. Het alternatief is unordered_multimap Klasse.
Een type dat een verwijzing biedt naar een element dat is opgeslagen in een hash_multimap.
typedef list<typename _Traits::value_type, typename _Traits::allocator_type>::reference reference;
Voorbeeld
// 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
Opmerking
Deze API is verouderd. Het alternatief is unordered_multimap Klasse.
Retourneert een iterator die de locatie adresseert die het laatste element in een omgekeerde hash_multimap slaagt.
const_reverse_iterator rend() const;
reverse_iterator rend();
Retourwaarde
Een omgekeerde bidirectionele iterator die de locatie afhandelt die het laatste element in een omgekeerde hash_multimap (de locatie die voorafging aan het eerste element in de niet-omgedraaide hash_multimap).
Opmerkingen
rend wordt gebruikt met een omgekeerde hash_multimap net zoals het einde wordt gebruikt met een hash_multimap.
Als de retourwaarde is rend toegewezen aan een const_reverse_iterator, kan het hash_multimap object niet worden gewijzigd. Als de retourwaarde rend is toegewezen aan een reverse_iterator, kan het hash_multimap object worden gewijzigd.
rend kan worden gebruikt om te testen of een omgekeerde iterator het einde van de hash_multimap heeft bereikt.
De waarde die wordt geretourneerd door rend mag niet worden afgetrokken.
Voorbeeld
// 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
Opmerking
Deze API is verouderd. Het alternatief is unordered_multimap Klasse.
Een type dat een bidirectionele iterator biedt waarmee een element in een omgekeerde hash_multimap kan worden gelezen of gewijzigd.
typedef list<typename Traits::value_type, typename Traits::allocator_type>::reverse_iterator reverse_iterator;
Opmerkingen
Een type reverse_iterator wordt gebruikt om de hash_multimap omgekeerd te doorlopen.
De reverse_iterator gedefinieerde door hash_multimap verwijst naar objecten van value_type, die van het type pair<const Key, Type> zijn. De waarde van de sleutel is beschikbaar via het eerste lidpaar en de waarde van het toegewezen element is beschikbaar via het tweede lid van het paar.
Voorbeeld
Zie het voorbeeld voor rbegin voor een voorbeeld van het declareren en gebruiken reverse_iteratorvan .
hash_multimap::size
Opmerking
Deze API is verouderd. Het alternatief is unordered_multimap Klasse.
Retourneert het aantal elementen in de hash_multimap.
size_type size() const;
Retourwaarde
De huidige lengte van de hash_multimap.
Voorbeeld
In het volgende voorbeeld ziet u het gebruik van de functie hash_multimap::size member.
// 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
Opmerking
Deze API is verouderd. Het alternatief is unordered_multimap Klasse.
Een niet-ondertekend geheel getaltype waarmee het aantal elementen in een hash_multimap wordt geteld.
typedef list<typename _Traits::value_type, typename _Traits::allocator_type>::size_type size_type;
Voorbeeld
Zie het voorbeeld voor de grootte voor een voorbeeld van het declareren en gebruiken van size_type
hash_multimap::wisselen
Opmerking
Deze API is verouderd. Het alternatief is unordered_multimap Klasse.
Uitwisseling van de elementen van twee hash_multimaps.
void swap(hash_multimap& right);
Parameterwaarden
rechts
De hash_multimap de elementen die moeten worden gewisseld of de hash_multimap waarvan de elementen moeten worden uitgewisseld met die van de hash_multimap.
Opmerkingen
De lidfunctie ongeldig maakt geen verwijzingen, aanwijzers of iterators die elementen aanwijzen in de twee hash_multimaps waarvan de elementen worden uitgewisseld.
Voorbeeld
// 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
Opmerking
Deze API is verouderd. Het alternatief is unordered_multimap Klasse.
Retourneert een iterator naar het eerste element in een hash_multimap met een sleutel die groter is dan een opgegeven sleutel.
iterator upper_bound(const Key& key);
const_iterator upper_bound(const Key& key) const;
Parameterwaarden
sleutel
De argumentsleutel die moet worden vergeleken met de sorteersleutel van een element uit de hash_multimap die wordt doorzocht.
Retourwaarde
Een iterator of const_iterator die de locatie van een element in een hash_multimap adresseert met een sleutel die groter is dan de argumentsleutel, of die de locatie adresseert die het laatste element in de hash_multimap slaagt als er geen overeenkomst voor de sleutel wordt gevonden.
Als de retourwaarde upper_bound is toegewezen aan een const_iterator, kan het hash_multimap object niet worden gewijzigd. Als de retourwaarde upper_bound is toegewezen aan een iterator, kan het hash_multimap object worden gewijzigd.
Voorbeeld
// 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
Opmerking
Deze API is verouderd. Het alternatief is unordered_multimap Klasse.
De lidfunctie retourneert een functieobject dat de volgorde van elementen in een hash_multimap bepaalt door de sleutelwaarden te vergelijken.
value_compare value_comp() const;
Retourwaarde
Retourneert het vergelijkingsfunctieobject dat een hash_multimap gebruikt om de elementen te ordenen.
Opmerkingen
Als voor een hash_multimap m twee elementen e1 (k1, d1) en e2(k2, d2) objecten van het type value_type zijn, waarbij k1 en k2 hun sleutels zijn van het type key_type en d1 en d2 de gegevens van het type mapped_type zijn, is dat m.value_comp()(e1, e2) gelijk aan .m.key_comp()(k1, k2) Een opgeslagen object definieert de lidfunctie
bool operator( value_type& left, value_type& right);
dat retourneert true als de sleutelwaarde van left voorgaat en niet gelijk is aan de sleutelwaarde van right in de sorteervolgorde.
Voorbeeld
// 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
Opmerking
Deze API is verouderd. Het alternatief is unordered_multimap Klasse.
Een type dat het type object aangeeft dat is opgeslagen in een hash_multimap.
typedef pair<const Key, Type> value_type;
Opmerkingen
value_type wordt gedeclareerd als koppelcont<key_type, mapped_type> en niet<key_type, mapped_type> omdat de sleutels van een associatieve container mogelijk niet worden gewijzigd met behulp van een niet-gekoppelde iterator of verwijzing.
Voorbeeld
// 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.
Zie ook
Thread Safety in de standaardbibliotheek van C++
Naslaginformatie over de C++ standaard bibliotheek