hash_multiset-klasse

De containerklasse hash_multiset is een uitbreiding van de C++-standaardbibliotheek en wordt gebruikt voor de opslag en het snel ophalen van gegevens uit een verzameling waarin de waarden van de elementen fungeren als de sleutelwaarden en niet uniek hoeven te zijn.

Syntaxis

template <class Key, class Traits =hash_compare<Key, less <Key>>, class Allocator =allocator <Key>>
class hash_multiset

Parameterwaarden

Sleutel
Het gegevenstype element dat moet worden opgeslagen in de hash_multiset.

eigenschappen
Het type dat twee functieobjecten bevat, een van klassevergelijkingen die een binair predicaat is waarmee twee elementwaarden kunnen worden vergeleken als sorteersleutels om hun relatieve volgorde te bepalen en een hash-functie die een unaire predicaat is die sleutelwaarden van de elementen toewijst aan niet-ondertekende gehele getallen van het type size_t. 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_multiset. Dit argument is optioneel en de standaardwaarde is allocator<Key>.

Opmerkingen

De hash_multiset 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. Verder is het een eenvoudige associatieve container omdat de elementwaarden de belangrijkste waarden zijn.

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

• Uniek in de zin dat elk van de elementen een unieke sleutel moet hebben. Omdat hash_multiset ook een eenvoudige associatieve container is, zijn de elementen ook uniek.

• 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 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 set kan niet rechtstreeks worden gewijzigd. In plaats daarvan moet u oude waarden verwijderen en elementen met nieuwe waarden invoegen.

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_multiset moet de associatieve container van keuze zijn wanneer de voorwaarden die de waarden aan hun sleutels koppelen, voldoen aan de toepassing. De elementen van een hash_multiset kunnen meerdere zijn en fungeren als hun eigen sorteersleutels, dus sleutels zijn niet uniek. Een model voor dit type structuur is een geordende lijst met woorden waarin de woorden meer dan één keer voorkomen. Als meerdere exemplaren van de woorden niet zijn toegestaan, zou een hash_set de juiste containerstructuur zijn geweest. Als er unieke definities als waarden aan de lijst met unieke trefwoorden zijn gekoppeld, is een hash_map een geschikte structuur om deze gegevens te bevatten. Als in plaats daarvan de definities niet uniek waren, zou een hash_multimap de gewenste container zijn.

De hash_multiset ordenen de volgorde die deze beheert door een opgeslagen hash-eigenschappenobject 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 sleutel van het type Keygeeft de aanroep Trait(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-quivalente 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 en een retourwaarde waar of onwaar. Een volgorde die wordt opgelegd aan een hash_multiset 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 zijn gedefinieerd als gelijkwaardig wanneer zowel f( x, y) als f( y, x) onwaar zijn. 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_multiset-klasse is een bidirectionele iterator, maar de functies van het klasselid invoegen en hash_multiset versies hebben die als sjabloonparameters een zwakkere invoer-iterator gebruiken, waarvan de functionaliteitsvereisten minimaal zijn dan die 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_multiset 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_multiset functionaliteit, maar het is voldoende om zinvol te kunnen praten over een reeks iterators [ first, last) in de context van de functies van het klasselid.

Constructeurs

Typedefs

Functies voor leden

Bedieners

Behoeften

Rubriek:<hash_set>

Naamruimte: stdext

hash_multiset::allocator_type

Een type dat de allocatorklasse vertegenwoordigt voor het hash_multiset-object.

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

Voorbeeld

Zie het voorbeeld voor get_allocator voor een voorbeeld met behulp van allocator_type

hash_multiset::begin

Retourneert een iterator die het eerste element in de hash_multiset adresseert.

const_iterator begin() const;

iterator begin();

Retourwaarde

Een bidirectionele iterator die het eerste element in de hash_multiset of de locatie slaagt in een lege hash_multiset.

Opmerkingen

Als de retourwaarde is begin toegewezen aan een const_iterator, kunnen de elementen in het hash_multiset-object niet worden gewijzigd. Als de retourwaarde begin is toegewezen aan een iterator, kunnen de elementen in het hash_multiset-object worden gewijzigd.

Voorbeeld

// hash_multiset_begin.cpp
// compile with: /EHsc
#include <hash_set>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_multiset <int> hms1;
   hash_multiset <int>::iterator hms1_Iter;
   hash_multiset <int>::const_iterator hms1_cIter;

   hms1.insert( 1 );
   hms1.insert( 2 );
   hms1.insert( 3 );

   hms1_Iter = hms1.begin( );
   cout << "The first element of hms1 is " << *hms1_Iter << endl;

   hms1_Iter = hms1.begin( );
   hms1.erase( hms1_Iter );

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

   hms1_cIter = hms1.begin( );
   cout << "The first element of hms1 is now " << *hms1_cIter << endl;
}

The first element of hms1 is 1
The first element of hms1 is now 2

hash_multiset::cbegin

Retourneert een const iterator die het eerste element in de hash_multiset aanpakt.

const_iterator cbegin() const;

Retourwaarde

Een const bidirectionele iterator die het eerste element in de hash_multiset of de locatie slaagt in een lege hash_multiset.

Opmerkingen

Met de retourwaarde van cbeginkan de elementen in het hash_multiset object niet worden gewijzigd.

Voorbeeld

// hash_multiset_cbegin.cpp
// compile with: /EHsc
#include <hash_multiset>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_multiset <int> hs1;
   hash_multiset <int>::const_iterator hs1_cIter;

   hs1.insert( 1 );
   hs1.insert( 2 );
   hs1.insert( 3 );

   hs1_cIter = hs1.cbegin( );
   cout << "The first element of hs1 is " << *hs1_cIter << endl;
}

The first element of hs1 is 1

hash_multiset::cend

Retourneert een const iterator waarmee de locatie wordt opgelost die het laatste element in een hash_multiset slaagt.

const_iterator cend() const;

Retourwaarde

Een const bidirectionele iterator die de locatie slaagt na het laatste element in een hash_multiset. Als de hash_multiset leeg is, hash_multiset::cend == hash_multiset::begin.

Opmerkingen

cend wordt gebruikt om te testen of een iterator het einde van de hash_multisetheeft bereikt. De waarde die wordt geretourneerd door cend mag niet worden afgetrokken.

Voorbeeld

// hash_multiset_cend.cpp
// compile with: /EHsc
#include <hash_multiset>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_multiset <int> hs1;
   hash_multiset <int> :: const_iterator hs1_cIter;

   hs1.insert( 1 );
   hs1.insert( 2 );
   hs1.insert( 3 );

   hs1_cIter = hs1.cend( );
   hs1_cIter--;
   cout << "The last element of hs1 is " << *hs1_cIter << endl;
}

The last element of hs1 is 3

hash_multiset::clear

Hiermee worden alle elementen van een hash_multiset gewist.

void clear();

Voorbeeld

// hash_multiset_clear.cpp
// compile with: /EHsc
#include <hash_set>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_multiset <int> hms1;

   hms1.insert( 1 );
   hms1.insert( 2 );

   cout << "The size of the hash_multiset is initially " << hms1.size( )
        << "." << endl;

   hms1.clear( );
   cout << "The size of the hash_multiset after clearing is "
        << hms1.size( ) << "." << endl;
}

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

hash_multiset::const_iterator

Een type dat een bidirectionele iterator biedt waarmee een const element in de hash_multiset 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.

Voorbeeld

Zie het voorbeeld voor het begin van een voorbeeld met behulp van const_iterator.

hash_multiset::const_pointer

Een type dat een aanwijzer naar een const element in een hash_multiset biedt.

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 const_iterator worden gebruikt voor toegang tot de elementen in een const hash_multiset-object.

hash_multiset::const_reference

Een type dat een verwijzing biedt naar een const element dat is opgeslagen in een hash_multiset voor het lezen en uitvoeren van bewerkingen const .

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

Voorbeeld

// hash_multiset_const_reference.cpp
// compile with: /EHsc
#include <hash_set>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_multiset <int> hms1;

   hms1.insert( 10 );
   hms1.insert( 20 );

   // Declare and initialize a const_reference &Ref1
   // to the 1st element
   const int &Ref1 = *hms1.begin( );

   cout << "The first element in the hash_multiset is "
        << Ref1 << "." << endl;

   // The following line would cause an error because the
   // const_reference cannot be used to modify the hash_multiset
   // Ref1 = Ref1 + 5;
}

The first element in the hash_multiset is 10.

hash_multiset::const_reverse_iterator

Een type dat een bidirectionele iterator biedt die elk const element in de hash_multiset 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_multiset omgekeerd te doorlopen.

Voorbeeld

Zie het voorbeeld voor rend voor een voorbeeld van het declareren en gebruiken van de const_reverse_iterator.

hash_multiset::count

Retourneert het aantal elementen in een hash_multiset 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_multiset.

Retourwaarde

Het aantal elementen in de hash_multiset met de parameter opgegeven sleutel.

Opmerkingen

De lidfunctie retourneert het aantal elementen in het volgende bereik:

[ lower_bound(key), upper_bound(key) ).

Voorbeeld

In het volgende voorbeeld ziet u het gebruik van de functie hash_multiset::count member.

// hash_multiset_count.cpp
// compile with: /EHsc
#include <hash_set>
#include <iostream>

int main( )
{
    using namespace std;
    using namespace stdext;
    hash_multiset<int> hms1;
    hash_multiset<int>::size_type i;

    hms1.insert(1);
    hms1.insert(1);

    // Keys do not need to be unique in hash_multiset,
    // so duplicates may exist.
    i = hms1.count(1);
    cout << "The number of elements in hms1 with a sort key of 1 is: "
         << i << "." << endl;

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

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

hash_multiset::crbegin

Retourneert een const iterator die het eerste element in een omgekeerde hash_multiset aanpakt.

const_reverse_iterator crbegin() const;

Retourwaarde

Een const omgekeerde bidirectionele iterator adresseren het eerste element in een omgekeerde hash_multiset of het aanpakken van wat het laatste element in de ongedraaide hash_multiset.

Opmerkingen

crbegin wordt gebruikt met een omgekeerde hash_multiset , net zoals hash_multiset::begin wordt gebruikt met een hash_multiset.

Met de retourwaarde van crbeginkan het hash_multiset object niet worden gewijzigd.

crbegin kan worden gebruikt om een hash_multiset achteruit te doorlopen.

Voorbeeld

// hash_multiset_crbegin.cpp
// compile with: /EHsc
#include <hash_multiset>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_multiset <int> hs1;
   hash_multiset <int>::const_reverse_iterator hs1_crIter;

   hs1.insert( 10 );
   hs1.insert( 20 );
   hs1.insert( 30 );

   hs1_crIter = hs1.crbegin( );
   cout << "The first element in the reversed hash_multiset is "
        << *hs1_crIter << "." << endl;
}

The first element in the reversed hash_multiset is 30.

hash_multiset::crend

Retourneert een const iterator die de locatie afspreekt waarop het laatste element in een omgekeerde hash_multiset is geslaagd.

const_reverse_iterator crend() const;

Retourwaarde

Een omgekeerde bidirectionele iterator waarmee de locatie wordt opgelost waarop het laatste element in een omgekeerde hash_multiset is geslaagd (de locatie die voorafging aan het eerste element in de niet-omgedraaide hash_multiset).

Opmerkingen

crend wordt gebruikt met een omgekeerde hash_multiset , net zoals hash_multiset::end wordt gebruikt met een hash_multiset.

Met de retourwaarde van crendkan het hash_multiset object niet worden gewijzigd.

crend kan worden gebruikt om te testen of een omgekeerde iterator het einde van de hash_multiset heeft bereikt.

Voorbeeld

// hash_multiset_crend.cpp
// compile with: /EHsc
#include <hash_multiset>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_multiset <int> hs1;
   hash_multiset <int>::const_reverse_iterator hs1_crIter;

   hs1.insert( 10 );
   hs1.insert( 20 );
   hs1.insert( 30 );

   hs1_crIter = hs1.crend( );
   hs1_crIter--;
   cout << "The last element in the reversed hash_multiset is "
        << *hs1_crIter << "." << endl;
}

The last element in the reversed hash_multiset is 10.

hash_multiset::d deductietype

Een ondertekend geheel getaltype dat het verschil biedt tussen twee iterators die elementen binnen dezelfde hash_multiset adresseert.

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 [ first, last) tussen de iterators first weer te geven en lastbevat het element dat is verwezen door first en het bereik van elementen tot, maar niet inclusief, het element dat door wordt verwezen last.

Houd er rekening mee dat hoewel difference_type deze beschikbaar is voor alle iterators die voldoen aan de vereisten van een invoer-iterator, die de klasse van bidirectionele iterators bevat die worden ondersteund door omkeerbare containers, zoals set. Aftrekken tussen iterators wordt alleen ondersteund door iterators voor willekeurige toegang die wordt geleverd door een container met willekeurige toegang, zoals vector of deque.

Voorbeeld

// hash_multiset_diff_type.cpp
// compile with: /EHsc
#include <iostream>
#include <hash_set>
#include <algorithm>

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

   hash_multiset <int> hms1;
   hash_multiset <int>::iterator hms1_Iter, hms1_bIter, hms1_eIter;

   hms1.insert( 20 );
   hms1.insert( 10 );

   // hash_multiset elements need not be unique
   hms1.insert( 20 );

   hms1_bIter = hms1.begin( );
   hms1_eIter = hms1.end( );

   hash_multiset <int>::difference_type   df_typ5, df_typ10,
        df_typ20;

   df_typ5 = count( hms1_bIter, hms1_eIter, 5 );
   df_typ10 = count( hms1_bIter, hms1_eIter, 10 );
   df_typ20 = count( hms1_bIter, hms1_eIter, 20 );

   // The keys & hence the elements of a hash_multiset
   // need not be unique and may occur multiple times
   cout << "The number '5' occurs " << df_typ5
        << " times in hash_multiset hms1.\n";
   cout << "The number '10' occurs " << df_typ10
        << " times in hash_multiset hms1.\n";
   cout << "The number '20' occurs " << df_typ20
        << " times in hash_multiset hms1.\n";

   // Count the number of elements in a hash_multiset
   hash_multiset <int>::difference_type  df_count = 0;
   hms1_Iter = hms1.begin( );
   while ( hms1_Iter != hms1_eIter)
   {
      df_count++;
      hms1_Iter++;
   }

   cout << "The number of elements in the hash_multiset hms1 is "
        << df_count << "." << endl;
}

The number '5' occurs 0 times in hash_multiset hms1.
The number '10' occurs 1 times in hash_multiset hms1.
The number '20' occurs 2 times in hash_multiset hms1.
The number of elements in the hash_multiset hms1 is 3.

hash_multiset::emplace

Hiermee voegt u een element in een hash_multiset.

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

Parameterwaarden

val-
De waarde van een element dat in de hash_multiset moet worden ingevoegd, tenzij het hash_multiset element al bevat of, meer in het algemeen, een element waarvan de sleutel gelijkgeordend is.

Retourwaarde

De emplace lidfunctie retourneert een iterator die verwijst naar de positie waar het nieuwe element is ingevoegd.

Voorbeeld

// hash_multiset_emplace.cpp
// compile with: /EHsc
#include <hash_set>
#include <iostream>
#include <string>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_multiset<string> hms3;
   string str1("a");

   hms3.emplace(move(str1));
   cout << "After the emplace insertion, hms3 contains "
      << *hms3.begin() << "." << endl;
}

After the emplace insertion, hms3 contains a.

hash_multiset::emplace_hint

Hiermee voegt u een element in een hash_multiset in, met een plaatsingshint.

template <class ValTy>
iterator insert(
    const_iterator where,
    ValTy&& val);

Parameterwaarden

val-
De waarde van een element dat in de hash_multiset moet worden ingevoegd, tenzij het hash_multiset element al bevat of, meer in het algemeen, een element waarvan de sleutel gelijkgeordend is.

waar
De plaats om te beginnen met zoeken naar het juiste invoegpunt. (Invoeging kan optreden in afgeschreven constante tijd, in plaats van logaritmische tijd, als de invoegpositie direct volgt waar.)

Retourwaarde

De functie hash_multiset::emplace retourneert een iterator die verwijst naar de positie waar het nieuwe element is ingevoegd in de hash_multiset.

Opmerkingen

Invoeging kan optreden in afgeschreven constante tijd, in plaats van logaritmische tijd, als de invoegpositie onmiddellijk volgt waar.

Voorbeeld

// hash_multiset_emplace_hint.cpp
// compile with: /EHsc
#include <hash_set>
#include <iostream>
#include <string>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_multiset<string> hms1;
   string str1("a");

   hms1.insert(hms1.begin(), move(str1));
   cout << "After the emplace insertion, hms1 contains "
      << *hms1.begin() << "." << endl;
}

After the emplace insertion, hms1 contains a.

hash_multiset::leeg

Test of een hash_multiset leeg is.

bool empty() const;

Retourwaarde

true als de hash_multiset leeg is; false als de hash_multiset geenmpty is.

Voorbeeld

// hash_multiset_empty.cpp
// compile with: /EHsc
#include <hash_set>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_multiset <int> hms1, hms2;
   hms1.insert ( 1 );

   if ( hms1.empty( ) )
      cout << "The hash_multiset hms1 is empty." << endl;
   else
      cout << "The hash_multiset hms1 is not empty." << endl;

   if ( hms2.empty( ) )
      cout << "The hash_multiset hms2 is empty." << endl;
   else
      cout << "The hash_multiset hms2 is not empty." << endl;
}

The hash_multiset hms1 is not empty.
The hash_multiset hms2 is empty.

hash_multiset::end

Retourneert een iterator die de locatie adresseert die het laatste element in een hash_multiset slaagt.

const_iterator end() const;

iterator end();

Retourwaarde

Een bidirectionele iterator die de locatie adresseert die het laatste element in een hash_multiset slaagt. Als de hash_multiset leeg is, hash_multiset::end == hash_multiset::begin.

Opmerkingen

end wordt gebruikt om te testen of een iterator het einde van de hash_multiset heeft bereikt. De waarde die wordt geretourneerd door end mag niet worden afgetrokken.

Voorbeeld

// hash_multiset_end.cpp
// compile with: /EHsc
#include <hash_set>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_multiset <int> hms1;
   hash_multiset <int> :: iterator hms1_Iter;
   hash_multiset <int> :: const_iterator hms1_cIter;

   hms1.insert( 1 );
   hms1.insert( 2 );
   hms1.insert( 3 );

   hms1_Iter = hms1.end( );
   hms1_Iter--;
   cout << "The last element of hms1 is " << *hms1_Iter << endl;

   hms1.erase( hms1_Iter );

   // The following 3 lines would err because the iterator is const
   // hms1_cIter = hms1.end( );
   // hms1_cIter--;
   // hms1.erase( hms1_cIter );

   hms1_cIter = hms1.end( );
   hms1_cIter--;
   cout << "The last element of hms1 is now " << *hms1_cIter << endl;
}

The last element of hms1 is 3
The last element of hms1 is now 2

hash_multiset::equal_range

Retourneert respectievelijk een paar iterators naar het eerste element in een hash_multiset met een sleutel die groter is dan een opgegeven sleutel en het eerste element in de hash_multiset 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_multiset die wordt doorzocht.

Retourwaarde

Een paar iterators waarbij 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_multiset_equal_range.cpp
// compile with: /EHsc
#include <hash_set>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   typedef hash_multiset<int> IntHSet;
   IntHSet hms1;
   hash_multiset <int> :: const_iterator hms1_RcIter;

   hms1.insert( 10 );
   hms1.insert( 20 );
   hms1.insert( 30 );

   pair <IntHSet::const_iterator, IntHSet::const_iterator> p1, p2;
   p1 = hms1.equal_range( 20 );

   cout << "The upper bound of the element with "
        << "a key of 20\nin the hash_multiset hms1 is: "
        << *(p1.second) << "." << endl;

   cout << "The lower bound of the element with "
        << "a key of 20\nin the hash_multiset hms1 is: "
        << *(p1.first) << "." << endl;

   // Compare the upper_bound called directly
   hms1_RcIter = hms1.upper_bound( 20 );
   cout << "A direct call of upper_bound( 20 ) gives "
        << *hms1_RcIter << "," << endl
        << "matching the 2nd element of the pair"
        << " returned by equal_range( 20 )." << endl;

   p2 = hms1.equal_range( 40 );

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

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

hash_multiset::gum

Hiermee verwijdert u een element of een reeks elementen in een hash_multiset 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 uit de hash_multiset moet worden verwijderd.

eerste
Positie van het eerste element dat uit de hash_multiset is verwijderd.

laatste
Positie vlak voorbij het laatste element dat uit de hash_multiset is verwijderd.

sleutel
De sleutel van de elementen die uit de hash_multiset moeten worden verwijderd.

Retourwaarde

Voor de eerste twee lidfuncties, een bidirectionele iterator die het eerste element aanwijst dat buiten alle verwijderde elementen blijft, of een aanwijzer naar het einde van de hash_multiset als er geen dergelijk element bestaat. Voor de functie derde lid is het aantal elementen dat uit de hash_multiset is verwijderd.

Opmerkingen

De lidfuncties genereren nooit een uitzondering.

Voorbeeld

In het volgende voorbeeld ziet u het gebruik van de functie hash_multiset::gumlid.

// hash_multiset_erase.cpp
// compile with: /EHsc
#include <hash_set>
#include <iostream>

int main()
{
    using namespace std;
    using namespace stdext;
    hash_multiset<int> hms1, hms2, hms3;
    hash_multiset<int> :: iterator pIter, Iter1, Iter2;
    int i;
    hash_multiset<int>::size_type n;

    for (i = 1; i < 5; i++)
    {
        hms1.insert(i);
        hms2.insert(i * i);
        hms3.insert(i - 1);
    }

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

    cout << "After the 2nd element is deleted,\n"
         << "the hash_multiset hms1 is:" ;
    for (pIter = hms1.begin(); pIter != hms1.end(); pIter++)
        cout << " " << *pIter;
    cout << "." << endl;

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

    cout << "After the middle two elements are deleted,\n"
         << "the hash_multiset hms2 is:" ;
    for (pIter = hms2.begin(); pIter != hms2.end(); pIter++)
        cout << " " << *pIter;
    cout << "." << endl;

    // The 3rd member function removes elements with a given  key
    n = hms3.erase(2);

    cout << "After the element with a key of 2 is deleted,\n"
         << "the hash_multiset hms3 is:" ;
    for (pIter = hms3.begin(); pIter != hms3.end(); pIter++)
        cout << " " << *pIter;
    cout << "." << endl;

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

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

    cout << "After another element with a key "
         << "equal to that of the 2nd element\n"
         << "is deleted, the hash_multiset hms3 is:" ;
    for (pIter = hms3.begin(); pIter != hms3.end(); pIter++)
        cout << " " << *pIter;
    cout << "." << endl;
}

After the 2nd element is deleted,
the hash_multiset hms1 is: 1 3 4.
After the middle two elements are deleted,
the hash_multiset hms2 is: 16 4.
After the element with a key of 2 is deleted,
the hash_multiset hms3 is: 0 1 3.
The number of elements removed from hms3 is: 1.
After another element with a key equal to that of the 2nd element
is deleted, the hash_multiset hms3 is: 0 3.

hash_multiset::find

Retourneert een iterator die de locatie van een element in een hash_multiset adresseert 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 argumentsleutel die moet worden vergeleken met de sorteersleutel van een element uit de hash_multiset die wordt doorzocht.

Retourwaarde

Een iterator of const_iterator die de locatie van een element dat overeenkomt met een opgegeven sleutel, of die de locatie adresseert die het laatste element in de hash_multiset slaagt als er geen overeenkomst voor de sleutel wordt gevonden.

Opmerkingen

De lidfunctie retourneert een iterator die een element in de hash_multiset aangeeft waarvan de sorteersleutel de argumentsleutel is equivalent onder een binair predicaat dat een volgorde veroorzaakt op basis van een relatie met minder dan vergelijkbaarheid.

Als de retourwaarde is find toegewezen aan een const_iterator, kan het hash_multiset object niet worden gewijzigd. Als de retourwaarde find aan een iteratorobject is toegewezen, kan het hash_multiset object worden gewijzigd.

Voorbeeld

// hash_multiset_find.cpp
// compile with: /EHsc
#include <hash_set>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_multiset <int> hms1;
   hash_multiset <int> :: const_iterator hms1_AcIter, hms1_RcIter;

   hms1.insert( 10 );
   hms1.insert( 20 );
   hms1.insert( 30 );

   hms1_RcIter = hms1.find( 20 );
   cout << "The element of hash_multiset hms1 with a key of 20 is: "
        << *hms1_RcIter << "." << endl;

   hms1_RcIter = hms1.find( 40 );

   // If no match is found for the key, end( ) is returned
   if ( hms1_RcIter == hms1.end( ) )
      cout << "The hash_multiset hms1 doesn't have an element "
           << "with a key of 40." << endl;
   else
      cout << "The element of hash_multiset hms1 with a key of 40 is: "
           << *hms1_RcIter << "." << endl;

   // The element at a specific location in the hash_multiset can be found
   // by using a dereferenced iterator addressing the location
   hms1_AcIter = hms1.end( );
   hms1_AcIter--;
   hms1_RcIter = hms1.find( *hms1_AcIter );
   cout << "The element of hms1 with a key matching "
        << "that of the last element is: "
        << *hms1_RcIter << "." << endl;
}

The element of hash_multiset hms1 with a key of 20 is: 20.
The hash_multiset hms1 doesn't have an element with a key of 40.
The element of hms1 with a key matching that of the last element is: 30.

hash_multiset::get_allocator

Retourneert een kopie van het allocatorobject dat wordt gebruikt om de hash_multiset samen te stellen.

Allocator get_allocator() const;

Retourwaarde

De allocator die door de hash_multiset wordt gebruikt voor het beheren van geheugen. Dit is de sjabloonparameter Allocatorvan de klasse.

Zie de sectie Opmerkingen van het Allocator voor meer informatie.

Opmerkingen

Toewijzingen voor de hash_multiset-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_multiset_get_allocator.cpp
// compile with: /EHsc
#include <hash_set>
#include <iostream>

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

   // The following lines declare objects
   // that use the default allocator.
   hash_multiset <int, hash_compare <int, less<int> > > hms1;
   hash_multiset <int, hash_compare <int, greater<int> > > hms2;
   hash_multiset <double, hash_compare <double,
      less<double> >, allocator<double> > hms3;

   hash_multiset <int, hash_compare <int,
      greater<int> > >::allocator_type hms2_Alloc;
   hash_multiset <double>::allocator_type hms3_Alloc;
   hms2_Alloc = hms2.get_allocator( );

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

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

   // The following lines create a hash_multiset hms4
   // with the allocator of hash_multiset hms1.
   hash_multiset <int>::allocator_type hms4_Alloc;
   hash_multiset <int> hms4;
   hms4_Alloc = hms2.get_allocator( );

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

hash_multiset::hash_multiset

Hiermee wordt een hash_multiset leeg bestand gemaakt of dat een kopie is van alle of een deel van een andere hash_multiset.

hash_multiset();

explicit hash_multiset(
    const Traits& Comp);

hash_multiset(
    const Traits& Comp,
    const Allocator& Al);

hash_multiset(
    const hash_multiset<Key, Traits, Allocator>& Right);

hash_multiset(
    hash_multiset&& Right
);
hash_multiset (initializer_list<Type> IList);

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

template <class InputIterator>
hash_multiset(
    InputIterator first,
    InputIterator last);

template <class InputIterator>
hash_multiset(
    InputIterator first,
    InputIterator last,
    const Traits& Comp);

template <class InputIterator>
hash_multiset(
    InputIterator first,
    InputIterator last,
    const Traits& Comp,
    const Allocator& Al);

Parameterwaarden

Al
De opslag-allocatorklasse die moet worden gebruikt voor dit hash_multiset object, dat standaard wordt gebruikt Allocator.

Comp
De vergelijkingsfunctie van het type const Traits dat wordt gebruikt om de elementen in de hash_multisetstandaardinstelling hash_comparete ordenen.

Rechts
De hash_multiset waarvan de geconstrueerde hash_multiset een kopie moet zijn.

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 die de elementen bevat die moeten worden gekopieerd.

Opmerkingen

Alle constructors slaan een type allocatorobject op dat de geheugenopslag voor de hash_multiset en die later kan worden geretourneerd door hash_multiset::get_allocator aan te roepen. De allocatorparameter wordt vaak weggelaten in de klassedeclaraties en voorverwerkingsmacro's die worden gebruikt om alternatieve allocators te vervangen.

Alle constructors initialiseren hun hash_multisets.

Alle constructors slaan een functieobject van het type Traits op dat wordt gebruikt om een volgorde tot stand te brengen tussen de sleutels en hash_multiset die later kunnen worden geretourneerd door hash_multiset::key_comp aan te roepen. Zie het Traits voor meer informatie.

De eerste drie constructors geven een lege initiële hash_multisetop, de tweede die het type vergelijkingsfunctie (Comp) aangeeft dat moet worden gebruikt bij het vaststellen van de volgorde van de elementen en het derde expliciet opgeven van het type allocator (Al) dat moet worden gebruikt. Het trefwoord explicit onderdrukt bepaalde soorten automatische typeconversie.

De vierde constructor verplaatst de hash_multisetRight.

De vijfde, zesde en zevende constructors gebruiken een initializer_list.

De laatste drie constructors kopiëren het bereik [ first, last) van een hash_multiset met toenemende explicietheid bij het opgeven van het type vergelijkingsfunctie van klasse Vergelijken en allocator.

De werkelijke volgorde van elementen in een gehashte setcontainer is afhankelijk van de hash-functie, de volgordefunctie en de huidige grootte van de hash-tabel en kan in het algemeen niet worden voorspeld zoals het kan met de setcontainer, waar deze alleen is bepaald door de volgordefunctie.

hash_multiset::insert

Hiermee voegt u een element of een reeks elementen in een hash_multiset in.

iterator insert(
    const Type& value);

iterator insert(
    iterator where,
    const Type& Al);

void insert(
    initializer_list<Type> IList);

iterator insert(
    const Type& value);

iterator insert(
    Iterator where,
    const Type& value);

template <class InputIterator>
void insert(
    InputIterator first,
    InputIterator last);

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

template <class ValTy>
iterator insert(
    const_iterator where,
    ValTy&& value);

Parameterwaarden

waarde
De waarde van een element dat in de hash_multiset moet worden ingevoegd, tenzij de hash_multiset dat element al bevat of, meer in het algemeen, een element waarvan de sleutel gelijkwaardig is gerangschikt.

waar
De plaats om te beginnen met zoeken naar het juiste invoegpunt. (Invoeging kan optreden in afgeschreven constante tijd, in plaats van logaritmische tijd, als de invoegpositie direct volgt waar.)

eerste
De positie van het eerste element dat moet worden gekopieerd uit een hash_multiset.

laatste
De positie net buiten het laatste element dat moet worden gekopieerd uit een hash_multiset.

IList
De initializer_list die de elementen bevat die moeten worden gekopieerd.

Retourwaarde

De eerste twee invoegfuncties retourneren een iterator die verwijst naar de positie waar het nieuwe element is ingevoegd.

De volgende drie lidfuncties gebruiken een initializer_list.

Met de functie derde lid wordt de reeks elementwaarden ingevoegd in een hash_multiset die overeenkomt met elk element dat wordt geadresseerd door een iterator van het bereik [ first, last) van een opgegeven hash_multiset.

Opmerkingen

Invoeging kan optreden in afgeschreven constante tijd voor de hintversie van invoegen, in plaats van logaritmische tijd, als de invoegpositie onmiddellijk volgt waar.

hash_multiset::iterator

Een type dat een bidirectionele iterator biedt waarmee elk element in een hash_multiset kan worden gelezen of gewijzigd.

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

Opmerkingen

Een type iterator kan worden gebruikt om de waarde van een element te wijzigen.

Voorbeeld

Zie het voorbeeld voor een voorbeeld van het declareren en gebruiken iteratorvan .

hash_multiset::key_comp

Hiermee wordt een kopie opgehaald van het vergelijkingsobject dat wordt gebruikt om sleutels in een hash_multiset te ordenen.

key_compare key_comp() const;

Retourwaarde

Retourneert de hash_multiset sjabloonparameter Traits, die functieobjecten bevat die worden gebruikt om de elementen van de container te hashen en te ordenen.

Zie het onderwerp hash_multiset Klas voor meer informatie over eigenschappen.

Opmerkingen

Het opgeslagen object definieert een lidfunctie:

bool operator<(const Key& _xVal, const Key& _yVal);

die retourneert true als _xVal deze voorafgaat en niet gelijk is aan _yVal in de sorteervolgorde.

Houd er rekening mee dat zowel key_compare alsvalue_comparesynoniemen zijn voor de sjabloonparameterEigenschappen. Beide typen worden geleverd voor de hash_multiset- en hash_multiset-klassen, waar ze identiek zijn, voor compatibiliteit met de hash_map- en hash_multimap-klassen, waar ze verschillend zijn.

Voorbeeld

// hash_multiset_key_comp.cpp
// compile with: /EHsc
#include <hash_set>
#include <iostream>

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

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

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

hash_multiset::key_compare

Een type dat twee functieobjecten biedt, een binair predicaat van klassevergelijking waarmee twee elementwaarden van een hash_multiset kunnen worden vergeleken om hun relatieve volgorde te bepalen en een unaire predicaat dat de elementen hashes.

typedef Traits key_compare;

Opmerkingen

key_compare is een synoniem voor de sjabloonparameter Traits.

Zie het onderwerp hash_multiset Klas voor meer informatie over eigenschappen.

Houd er rekening mee dat zowel key_compare als value_compare synoniemen zijn voor de sjabloonparameter Traits. Beide typen worden geleverd voor de hash_set- en hash_multiset-klassen, waar ze identiek zijn, voor compatibiliteit met de hash_map- en hash_multimap-klassen, waar ze verschillend zijn.

Voorbeeld

Zie een voorbeeld voor key_comp voor een voorbeeld van het declareren en gebruiken key_comparevan .

hash_multiset::key_type

Een type dat een functieobject biedt waarmee sorteersleutels kunnen worden vergeleken om de relatieve volgorde van twee elementen in de hash_multiset te bepalen.

typedef Key key_type;

Opmerkingen

key_type is een synoniem voor de parametersleutel van de sjabloon.

Houd er rekening mee dat zowel key_typeals value_type synoniemen zijn voor de parametersleutel van de sjabloon. Beide typen worden geleverd voor de set- en multisetklassen, waar ze identiek zijn, voor compatibiliteit met de kaart- en multimapklassen, waar ze verschillend zijn.

Zie de sectie Opmerkingen van het onderwerp hash_multiset Klas voor meer informatie over Key.

Voorbeeld

Zie een voorbeeld voor value_type voor een voorbeeld van het declareren en gebruiken key_typevan .

hash_multiset::lower_bound

Retourneert een iterator naar het eerste element in een hash_multiset met een sleutel die gelijk is aan of groter is dan een opgegeven sleutel.

const_iterator lower_bound(const Key& key) const;

iterator lower_bound(const Key& key);

Parameterwaarden

sleutel
De argumentsleutel die moet worden vergeleken met de sorteersleutel van een element uit de hash_multiset die wordt doorzocht.

Retourwaarde

Een iterator of const_iterator die de locatie van het eerste element in een hash_multiset 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_multiset slaagt als er geen overeenkomst voor de sleutel wordt gevonden.

Voorbeeld

// hash_multiset_lower_bound.cpp
// compile with: /EHsc
#include <hash_set>
#include <iostream>

int main() {
   using namespace std;
   using namespace stdext;
   hash_multiset <int> hms1;
   hash_multiset <int> :: const_iterator hms1_AcIter, hms1_RcIter;

   hms1.insert( 10 );
   hms1.insert( 20 );
   hms1.insert( 30 );

   hms1_RcIter = hms1.lower_bound( 20 );
   cout << "The element of hash_multiset hms1 with a key of 20 is: "
        << *hms1_RcIter << "." << endl;

   hms1_RcIter = hms1.lower_bound( 40 );

   // If no match is found for the key, end( ) is returned
   if ( hms1_RcIter == hms1.end( ) )
      cout << "The hash_multiset hms1 doesn't have an element "
           << "with a key of 40." << endl;
   else
      cout << "The element of hash_multiset hms1 with a key of 40 is: "
           << *hms1_RcIter << "." << endl;

   // An element at a specific location in the hash_multiset can be found
   // by using a dereferenced iterator that addresses the location
   hms1_AcIter = hms1.end( );
   hms1_AcIter--;
   hms1_RcIter = hms1.lower_bound( *hms1_AcIter );
   cout << "The element of hms1 with a key matching "
        << "that of the last element is: "
        << *hms1_RcIter << "." << endl;
}

hash_multiset::max_size

Retourneert de maximumlengte van de hash_multiset.

size_type max_size() const;

Retourwaarde

De maximale lengte van de hash_multiset.

Voorbeeld

// hash_multiset_max_size.cpp
// compile with: /EHsc
#include <hash_set>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_multiset <int> hms1;
   hash_multiset <int>::size_type i;

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

hash_multiset::operator=

Vervangt de elementen van de hash_multiset door een kopie van een andere hash_multiset.

hash_multiset& operator=(const hash_multiset& right);

hash_multiset& operator=(hash_multiset&& right);

Parameterwaarden

rechts
De hash_multiset worden gekopieerd naar de hash_multiset.

Opmerkingen

Na het wissen van bestaande elementen in een hash_multiset, kopieert operator= of verplaatst u de inhoud van rechts naar de hash_multiset.

Voorbeeld

// hash_multiset_operator_as.cpp
// compile with: /EHsc
#include <hash_multiset>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_multiset<int> v1, v2, v3;
   hash_multiset<int>::iterator iter;

   v1.insert(10);

   cout << "v1 = " ;
   for (iter = v1.begin(); iter != v1.end(); iter++)
      cout << iter << " ";
   cout << endl;

   v2 = v1;
   cout << "v2 = ";
   for (iter = v2.begin(); iter != v2.end(); iter++)
      cout << iter << " ";
   cout << endl;

// move v1 into v2
   v2.clear();
   v2 = move(v1);
   cout << "v2 = ";
   for (iter = v2.begin(); iter != v2.end(); iter++)
      cout << iter << " ";
   cout << endl;
}

hash_multiset::p ointer

Een type dat een aanwijzer naar een element in een hash_multiset 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 multiset-object.

hash_multiset::rbegin

Retourneert een iterator die het eerste element in een omgekeerde hash_multiset adresseert.

const_reverse_iterator rbegin() const;

reverse_iterator rbegin();

Retourwaarde

Een omgekeerde bidirectionele iterator die het eerste element in een omgekeerde hash_multiset adresseren of het aanpakken van wat het laatste element in de niet-omgedraaide hash_multiset was geweest.

Opmerkingen

rbegin wordt gebruikt met een omgekeerde hash_multiset net zoals het begin wordt gebruikt met een hash_multiset.

Als de retourwaarde rbegin is toegewezen aan een const_reverse_iterator, kan het hash_multiset object niet worden gewijzigd. Als de retourwaarde rbegin is toegewezen aan een reverse_iterator, kan het hash_multiset object worden gewijzigd.

rbegin kan worden gebruikt om een hash_multiset achteruit te doorlopen.

Voorbeeld

// hash_multiset_rbegin.cpp
// compile with: /EHsc
#include <hash_set>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_multiset <int> hms1;
   hash_multiset <int>::iterator hms1_Iter;
   hash_multiset <int>::reverse_iterator hms1_rIter;

   hms1.insert( 10 );
   hms1.insert( 20 );
   hms1.insert( 30 );

   hms1_rIter = hms1.rbegin( );
   cout << "The first element in the reversed hash_multiset is "
        << *hms1_rIter << "." << endl;

   // begin can be used to start an iteration
   // through a hash_multiset in a forward order
   cout << "The hash_multiset is: ";
   for ( hms1_Iter = hms1.begin( ) ; hms1_Iter != hms1.end( );
         hms1_Iter++ )
      cout << *hms1_Iter << " ";
   cout << endl;

   // rbegin can be used to start an iteration
   // through a hash_multiset in a reverse order
   cout << "The reversed hash_multiset is: ";
   for ( hms1_rIter = hms1.rbegin( ) ; hms1_rIter != hms1.rend( );
         hms1_rIter++ )
      cout << *hms1_rIter << " ";
   cout << endl;

   // A hash_multiset element can be erased by dereferencing to its key
   hms1_rIter = hms1.rbegin( );
   hms1.erase ( *hms1_rIter );

   hms1_rIter = hms1.rbegin( );
   cout << "After the erasure, the first element "
        << "in the reversed hash_multiset is "<< *hms1_rIter << "."
        << endl;
}

The first element in the reversed hash_multiset is 30.
The hash_multiset is: 10 20 30
The reversed hash_multiset is: 30 20 10
After the erasure, the first element in the reversed hash_multiset is 20.

hash_multiset::reference

Een type dat een verwijzing biedt naar een element dat is opgeslagen in een hash_multiset.

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

Voorbeeld

// hash_multiset_reference.cpp
// compile with: /EHsc
#include <hash_set>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_multiset <int> hms1;

   hms1.insert( 10 );
   hms1.insert( 20 );

   // Declare and initialize a reference &Ref1 to the 1st element
   int &Ref1 = *hms1.begin( );

   cout << "The first element in the hash_multiset is "
        << Ref1 << "." << endl;

   // The value of the 1st element of the hash_multiset can be
   // changed by operating on its (non const) reference
   Ref1 = Ref1 + 5;

   cout << "The first element in the hash_multiset is now "
        << *hms1.begin() << "." << endl;
}

The first element in the hash_multiset is 10.
The first element in the hash_multiset is now 15.

hash_multiset::rend

Retourneert een iterator waarmee de locatie wordt opgelost die het laatste element in een omgekeerde hash_multiset 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_multiset (de locatie die voorafging aan het eerste element in de niet-omgedraaide hash_multiset).

Opmerkingen

rend wordt gebruikt met een omgekeerde hash_multiset net zoals het einde wordt gebruikt met een hash_multiset.

Als de retourwaarde rend is toegewezen aan een const_reverse_iterator, kan het hash_multiset object niet worden gewijzigd. Als de retourwaarde rend is toegewezen aan een reverse_iterator, kan het hash_multiset object worden gewijzigd. De waarde die wordt geretourneerd door rend mag niet worden afgetrokken.

rend kan worden gebruikt om te testen of een omgekeerde iterator het einde van de hash_multiset heeft bereikt.

Voorbeeld

// hash_multiset_rend.cpp
// compile with: /EHsc
#include <hash_set>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_multiset <int> hms1;
   hash_multiset <int>::iterator hms1_Iter;
   hash_multiset <int>::reverse_iterator hms1_rIter;
   hash_multiset <int>::const_reverse_iterator hms1_crIter;

   hms1.insert( 10 );
   hms1.insert( 20 );
   hms1.insert( 30 );

   hms1_rIter = hms1.rend( );
   hms1_rIter--;
   cout << "The last element in the reversed hash_multiset is "
        << *hms1_rIter << "." << endl;

   // end can be used to terminate an iteration
   // through a hash_multiset in a forward order
   cout << "The hash_multiset is: ";
   for ( hms1_Iter = hms1.begin( ) ; hms1_Iter != hms1.end( );
         hms1_Iter++ )
      cout << *hms1_Iter << " ";
   cout << "." << endl;

   // rend can be used to terminate an iteration
   // through a hash_multiset in a reverse order
   cout << "The reversed hash_multiset is: ";
   for ( hms1_rIter = hms1.rbegin( ) ; hms1_rIter != hms1.rend( );
         hms1_rIter++ )
      cout << *hms1_rIter << " ";
   cout << "." << endl;

   hms1_rIter = hms1.rend( );
   hms1_rIter--;
   hms1.erase ( *hms1_rIter );

   hms1_rIter = hms1.rend( );
   hms1_rIter--;
   cout << "After the erasure, the last element in the "
        << "reversed hash_multiset is " << *hms1_rIter << "."
        << endl;
}

The last element in the reversed hash_multiset is 10.
The hash_multiset is: 10 20 30 .
The reversed hash_multiset is: 30 20 10 .
After the erasure, the last element in the reversed hash_multiset is 20.

hash_multiset::reverse_iterator

Een type dat een bidirectionele iterator biedt waarmee een element in een omgekeerde hash_multiset 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_multiset omgekeerd te doorlopen.

Voorbeeld

Zie een voorbeeld voor rbegin voor een voorbeeld van hoe u declareert en gebruikt reverse_iterator.

hash_multiset::size

Retourneert het aantal elementen in de hash_multiset.

size_type size() const;

Retourwaarde

De huidige lengte van de hash_multiset.

Voorbeeld

// hash_multiset_size.cpp
// compile with: /EHsc
#include <hash_set>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_multiset <int> hms1;
   hash_multiset <int> :: size_type i;

   hms1.insert( 1 );
   i = hms1.size( );
   cout << "The hash_multiset length is " << i << "." << endl;

   hms1.insert( 2 );
   i = hms1.size( );
   cout << "The hash_multiset length is now " << i << "." << endl;
}

The hash_multiset length is 1.
The hash_multiset length is now 2.

hash_multiset::size_type

Een niet-ondertekend geheel getaltype dat het aantal elementen in een hash_multiset kan vertegenwoordigen.

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

Voorbeeld

Zie een voorbeeld voor de grootte van een voorbeeld van het declareren en gebruiken van size_type

hash_multiset::wisselen

De elementen van twee hash_multisets uitwisselen.

void swap(hash_multiset& right);

Parameterwaarden

rechts
Het argument hash_multiset de elementen die moeten worden gewisseld met de doel-hash_multiset.

Opmerkingen

De lidfunctie ongeldig maakt geen verwijzingen, aanwijzers of iterators die elementen aanwijzen in de twee hash_multisets waarvan de elementen worden uitgewisseld.

Voorbeeld

// hash_multiset_swap.cpp
// compile with: /EHsc
#include <hash_set>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_multiset <int> hms1, hms2, hms3;
   hash_multiset <int>::iterator hms1_Iter;

   hms1.insert( 10 );
   hms1.insert( 20 );
   hms1.insert( 30 );
   hms2.insert( 100 );
   hms2.insert( 200 );
   hms3.insert( 300 );

   cout << "The original hash_multiset hms1 is:";
   for ( hms1_Iter = hms1.begin( ); hms1_Iter != hms1.end( );
         hms1_Iter++ )
         cout << " " << *hms1_Iter;
   cout   << "." << endl;

   // This is the member function version of swap
   hms1.swap( hms2 );

   cout << "After swapping with hms2, list hms1 is:";
   for ( hms1_Iter = hms1.begin( ); hms1_Iter != hms1.end( );
         hms1_Iter++ )
         cout << " " << *hms1_Iter;
   cout  << "." << endl;

   // This is the specialized template version of swap
   swap( hms1, hms3 );

   cout << "After swapping with hms3, list hms1 is:";
   for ( hms1_Iter = hms1.begin( ); hms1_Iter != hms1.end( );
         hms1_Iter++ )
         cout << " " << *hms1_Iter;
   cout   << "." << endl;
}

The original hash_multiset hms1 is: 10 20 30.
After swapping with hms2, list hms1 is: 200 100.
After swapping with hms3, list hms1 is: 300.

hash_multiset::upper_bound

Retourneert een iterator naar het eerste element in een hash_multiset met een sleutel die groter is dan een opgegeven sleutel.

const_iterator upper_bound(const Key& key) const;

iterator upper_bound(const Key& key);

Parameterwaarden

sleutel
De argumentsleutel die moet worden vergeleken met de sorteersleutel van een element uit de hash_multiset die wordt doorzocht.

Retourwaarde

Een iterator of const_iterator die de locatie van het eerste element in een hash_multiset adresseert met een sleutel die groter is dan de argumentsleutel, of die de locatie adresseert die het laatste element in de hash_multiset slaagt als er geen overeenkomst voor de sleutel wordt gevonden.

Voorbeeld

// hash_multiset_upper_bound.cpp
// compile with: /EHsc
#include <hash_set>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_multiset <int> hms1;
   hash_multiset <int> :: const_iterator hms1_AcIter, hms1_RcIter;

   hms1.insert( 10 );
   hms1.insert( 20 );
   hms1.insert( 30 );

   hms1_RcIter = hms1.upper_bound( 20 );
   cout << "The first element of hash_multiset hms1" << endl
        << "with a key greater than 20 is: "
        << *hms1_RcIter << "." << endl;

   hms1_RcIter = hms1.upper_bound( 30 );

   // If no match is found for the key, end( ) is returned
   if ( hms1_RcIter == hms1.end( ) )
      cout << "The hash_multiset hms1 doesn't have an element\n"
           << "with a key greater than 30." << endl;
   else
      cout << "The element of hash_multiset hms1"
           << "with a key > 40 is: "
           << *hms1_RcIter << "." << endl;

   // An element at a specific location in the hash_multiset can be
   // found by using a dereferenced iterator addressing the location
   hms1_AcIter = hms1.begin( );
   hms1_RcIter = hms1.upper_bound( *hms1_AcIter );
   cout << "The first element of hms1 with a key greater than "
        << endl << "that of the initial element of hms1 is: "
        << *hms1_RcIter << "." << endl;
}

The first element of hash_multiset hms1
with a key greater than 20 is: 30.
The hash_multiset hms1 doesn't have an element
with a key greater than 30.
The first element of hms1 with a key greater than
that of the initial element of hms1 is: 20.

hash_multiset::value_comp

Hiermee wordt een kopie opgehaald van het vergelijkingsobject dat wordt gebruikt om elementwaarden in een hash_multiset te ordenen.

value_compare value_comp() const;

Retourwaarde

Retourneert de hash_multiset sjabloonparameter Traits, die functieobjecten bevat die worden gebruikt om te hashen en elementen van de container te ordenen.

Zie het onderwerp hash_multiset Klas voor meer informatie over eigenschappen.

Opmerkingen

Het opgeslagen object definieert een lidfunctie:

bool-operator( constKey&_xVal, const Key&_yVal);

die retourneert true als _xVal deze voorafgaat en niet gelijk is aan _yVal in de sorteervolgorde.

Houd er rekening mee dat zowel key_compare alsvalue_comparesynoniemen zijn voor de sjabloonparameterEigenschappen. Beide typen worden geleverd voor de hash_multiset- en hash_multiset-klassen, waar ze identiek zijn, voor compatibiliteit met de hash_map- en hash_multimap-klassen, waar ze verschillend zijn.

Voorbeeld

// hash_multiset_value_comp.cpp
// compile with: /EHsc
#include <hash_set>
#include <iostream>

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

   hash_multiset <int, hash_compare < int, less<int> > > hms1;
   hash_multiset <int, hash_compare < int, less<int> > >::value_compare
      vc1 = hms1.value_comp( );
   bool result1 = vc1( 2, 3 );
   if( result1 == true )
   {
      cout << "vc1( 2,3 ) returns value of true, "
           << "where vc1 is the function object of hms1."
           << endl;
   }
   else
   {
      cout << "vc1( 2,3 ) returns value of false, "
           << "where vc1 is the function object of hms1."
           << endl;
   }

   hash_multiset <int, hash_compare < int, greater<int> > > hms2;
   hash_multiset<int, hash_compare < int, greater<int> > >::
           value_compare vc2 = hms2.value_comp( );
   bool result2 = vc2( 2, 3 );
   if( result2 == true )
   {
      cout << "vc2( 2,3 ) returns value of true, "
           << "where vc2 is the function object of hms2."
           << endl;
   }
   else
   {
      cout << "vc2( 2,3 ) returns value of false, "
           << "where vc2 is the function object of hms2."
           << endl;
   }
}

vc1( 2,3 ) returns value of true, where vc1 is the function object of hms1.
vc2( 2,3 ) returns value of false, where vc2 is the function object of hms2.

hash_multiset::value_compare

Een type dat twee functieobjecten biedt, een binair predicaat van klassevergelijking waarmee twee elementwaarden van een hash_multiset kunnen worden vergeleken om hun relatieve volgorde te bepalen en een unaire predicaat dat de elementen hashes.

typedef key_compare value_compare;

Opmerkingen

value_compare is een synoniem voor de sjabloonparameter Traits.

Zie het onderwerp hash_multiset Klas voor meer informatie over eigenschappen.

Houd er rekening mee dat zowel key_compare als value_comparesynoniemen zijn voor de sjabloonparameterEigenschappen. Beide typen worden geleverd voor de klassenset en multiset, waar ze identiek zijn, voor compatibiliteit met de klassentoewijzing en multimap, waar ze verschillend zijn.

Voorbeeld

Zie een voorbeeld voor value_comp voor een voorbeeld van het declareren en gebruiken value_comparevan .

hash_multiset::value_type

Een type dat een object beschrijft dat is opgeslagen als een element als een hash_multiset in de capaciteit als een waarde.

typedef Key value_type;

Voorbeeld

// hash_multiset_value_type.cpp
// compile with: /EHsc
#include <hash_set>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_multiset <int> hms1;
   hash_multiset <int>::iterator hms1_Iter;

   // Declare value_type
   hash_multiset <int> :: value_type hmsvt_Int;

   hmsvt_Int = 10;   // Initialize value_type

   // Declare key_type
   hash_multiset <int> :: key_type hmskt_Int;
   hmskt_Int = 20;             // Initialize key_type

   hms1.insert( hmsvt_Int );         // Insert value into s1
   hms1.insert( hmskt_Int );         // Insert key into s1

   // A hash_multiset accepts key_types or value_types as elements
   cout << "The hash_multiset has elements:";
   for ( hms1_Iter = hms1.begin() ; hms1_Iter != hms1.end( );
         hms1_Iter++)
      cout << " " << *hms1_Iter;
      cout << "." << endl;
}

The hash_multiset has elements: 10 20.

Zie ook

Thread Safety in de standaardbibliotheek van C++
Naslaginformatie over de C++ standaard bibliotheek