hash_set-klasse

De containerklasse hash_set 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 uniek zijn en fungeren als de sleutelwaarden.

Syntaxis

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

Parameterwaarden

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

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_set. Dit argument is optioneel en de standaardwaarde is allocator<Key>.

Opmerkingen

De hash_set 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_set 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 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 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_set 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. De elementen van een hash_set zijn uniek en fungeren als hun eigen sorteersleutels. Een model voor dit type structuur is een geordende lijst met woorden waarin de woorden slechts één keer kunnen voorkomen. Als meerdere exemplaren van de woorden zijn toegestaan, is een hash_multiset de juiste containerstructuur. Als waarden moeten worden gekoppeld aan een lijst met unieke sleutelwoorden, is een hash_map een geschikte structuur om deze gegevens te bevatten. Als in plaats daarvan de sleutels niet uniek zijn, is een hash_multimap de gewenste container.

De hash_set bestelt 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 hetzelfde gedrag vertonen als een object van klasse hash_compare<Sleutel, minder<sleutel>>. Voor alle waarden key van het type Sleutel levert de call Trait(key) een verdeling van 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 en een retourwaarde waar of onwaar. Een orde die wordt opgelegd aan een hash_set 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_set-klasse is een bidirectionele iterator, maar de functies van het klasselid invoegen en hash_set 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 set 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 set functionaliteiten, 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_set::allocator_type

Een type dat de allocatorklasse vertegenwoordigt voor het hash_set-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 onderwerp hash_set Klas voor meer informatie over Allocator.

Voorbeeld

Zie een voorbeeld voor get_allocator voor een voorbeeld dat gebruikmaakt van allocator_type.

hash_set::begin

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

const_iterator begin() const;

iterator begin();

Retourwaarde

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

Opmerkingen

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

Voorbeeld

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

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

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

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

   hs1_Iter = hs1.begin( );
   hs1.erase( hs1_Iter );

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

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

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

hash_set::cbegin

Retourneert een const iterator die het eerste element in de hash_set adresseert.

const_iterator cbegin() const;

Retourwaarde

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

Opmerkingen

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

Voorbeeld

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

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_set <int> hs1;
   hash_set <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_set::cend

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

const_iterator cend() const;

Retourwaarde

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

Opmerkingen

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

Voorbeeld

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

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_set <int> hs1;
   hash_set <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_set::clear

Hiermee worden alle elementen van een hash_set gewist.

void clear();

Voorbeeld

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

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_set <int> hs1;

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

   cout << "The size of the hash_set is initially " << hs1.size( )
        << "." << endl;

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

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

hash_set::const_iterator

Een type dat een bidirectionele iterator biedt die een const element in de hash_set kan lezen.

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 dat gebruikmaakt van const_iterator.

hash_set::const_pointer

Een type dat een aanwijzer naar een const element in een hash_set 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 om toegang te krijgen tot de elementen in een const hash_set-object.

hash_set::const_reference

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

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

Voorbeeld

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

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_set <int> hs1;

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

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

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

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

The first element in the hash_set is 10.

hash_set::const_reverse_iterator

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

Voorbeeld

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

hash_set::count

Retourneert het aantal elementen in een hash_set 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_set.

Retourwaarde

1 als de hash_set een element bevat waarvan de sorteersleutel overeenkomt met de parametersleutel.

0 als de hash_set geen element met een overeenkomende sleutel bevat.

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_set::count member.

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

int main( )
{
    using namespace std;
    using namespace stdext;
    hash_set<int> hs1;
    hash_set<int>::size_type i;

    hs1.insert(1);
    hs1.insert(1);

    // Keys must be unique in hash_set, so duplicates are ignored.
    i = hs1.count(1);
    cout << "The number of elements in hs1 with a sort key of 1 is: "
         << i << "." << endl;

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

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

hash_set::crbegin

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

const_reverse_iterator crbegin() const;

Retourwaarde

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

Opmerkingen

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

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

crbegin kan worden gebruikt om een hash_set achteruit te doorlopen.

Voorbeeld

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

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_set <int> hs1;
   hash_set <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_set is "
        << *hs1_crIter << "." << endl;
}

The first element in the reversed hash_set is 30.

hash_set::crend

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

const_reverse_iterator crend() const;

Retourwaarde

Een const omgekeerde bidirectionele iterator die de locatie die het laatste element in een omgekeerde hash_set afhandelt (de locatie die voorafging aan het eerste element in de niet-omgedraaide hash_set).

Opmerkingen

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

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

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

Voorbeeld

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

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_set <int> hs1;
   hash_set <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_set is "
        << *hs1_crIter << "." << endl;
}

The last element in the reversed hash_set is 10.

hash_set::d deductietype

Een ondertekend geheel getal dat kan worden gebruikt om het aantal elementen van een hash_set 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 [ 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, wordt aftrekken tussen iterators alleen ondersteund door iterators voor willekeurige toegang die wordt geleverd door een willekeurige toegangscontainer, zoals vector of deque.

Voorbeeld

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

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

   hash_set <int> hs1;
   hash_set <int>::iterator hs1_Iter, hs1_bIter, hs1_eIter;

   hs1.insert( 20 );
   hs1.insert( 10 );
   hs1.insert( 20 );   // Won't insert as hash_set elements are unique

   hs1_bIter = hs1.begin( );
   hs1_eIter = hs1.end( );

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

   df_typ5 = count( hs1_bIter, hs1_eIter, 5 );
   df_typ10 = count( hs1_bIter, hs1_eIter, 10 );
   df_typ20 = count( hs1_bIter, hs1_eIter, 20 );

   // The keys, and hence the elements, of a hash_set are unique,
   // so there is at most one of a given value
   cout << "The number '5' occurs " << df_typ5
        << " times in hash_set hs1.\n";
   cout << "The number '10' occurs " << df_typ10
        << " times in hash_set hs1.\n";
   cout << "The number '20' occurs " << df_typ20
        << " times in hash_set hs1.\n";

   // Count the number of elements in a hash_set
   hash_set <int>::difference_type  df_count = 0;
   hs1_Iter = hs1.begin( );
   while ( hs1_Iter != hs1_eIter)
   {
      df_count++;
      hs1_Iter++;
   }

   cout << "The number of elements in the hash_set hs1 is: "
        << df_count << "." << endl;
}

The number '5' occurs 0 times in hash_set hs1.
The number '10' occurs 1 times in hash_set hs1.
The number '20' occurs 1 times in hash_set hs1.
The number of elements in the hash_set hs1 is: 2.

hash_set::emplace

Hiermee voegt u een element in een hash_set.

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

Parameterwaarden

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

Retourwaarde

De emplace lidfunctie retourneert een paar waarvan bool het onderdeel retourneert true als er een invoeging is gemaakt en false of het hash_set al een element bevat waarvan de sleutel een equivalente waarde in de volgorde heeft en waarvan het iteratoronderdeel het adres retourneert waar een nieuw element is ingevoegd of waar het element zich al bevond.

Voorbeeld

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

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

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

After the emplace insertion, hs3 contains a.

hash_set::emplace_hint

Hiermee voegt u een element in een hash_set.

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

Parameterwaarden

val-
De waarde van een element dat in de hash_set moet worden ingevoegd, tenzij het hash_set 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 onmiddellijk volgt op _Where.)

Retourwaarde

De functie hash_set::emplace retourneert een iterator die verwijst naar de positie waar het nieuwe element is ingevoegd in het hash_setelement of waar het bestaande element met gelijkwaardige volgorde zich bevindt.

Opmerkingen

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

Voorbeeld

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

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

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

After the emplace insertion, hs3 contains a.

hash_set::leeg

Test of een hash_set leeg is.

bool empty() const;

Retourwaarde

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

Voorbeeld

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

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_set <int> hs1, hs2;
   hs1.insert ( 1 );

   if ( hs1.empty( ) )
      cout << "The hash_set hs1 is empty." << endl;
   else
      cout << "The hash_set hs1 is not empty." << endl;

   if ( hs2.empty( ) )
      cout << "The hash_set hs2 is empty." << endl;
   else
      cout << "The hash_set hs2 is not empty." << endl;
}

The hash_set hs1 is not empty.
The hash_set hs2 is empty.

hash_set::end

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

const_iterator end() const;

iterator end();

Retourwaarde

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

Opmerkingen

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

Voorbeeld

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

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

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

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

   hs1.erase( hs1_Iter );

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

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

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

hash_set::equal_range

Retourneert respectievelijk een paar iterators naar het eerste element in een hash-set met een sleutel die gelijk is aan een opgegeven sleutel en aan het eerste element in de hashset met een sleutel die 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_set 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 die wordt geretourneerd door de lidfunctie, gebruikt u pr. gebruik eerst *(pr) om de ondergrens-iterator te deductie 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 deductie te deducteren, gebruikt u *(pr. seconde).

Voorbeeld

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

int main( )
{
   using namespace std;
   using namespace stdext;
   typedef hash_set<int> IntHSet;
   IntHSet hs1;
   hash_set <int> :: const_iterator hs1_RcIter;

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

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

   cout << "The upper bound of the element with "
        << "a key of 20 in the hash_set hs1 is: "
        << *(p1.second) << "." << endl;

   cout << "The lower bound of the element with "
        << "a key of 20 in the hash_set hs1 is: "
        << *(p1.first) << "." << endl;

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

   p2 = hs1.equal_range( 40 );

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

The upper bound of the element with a key of 20 in the hash_set hs1 is: 30.
The lower bound of the element with a key of 20 in the hash_set hs1 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_set hs1 doesn't have an element with a key greater than or equal to 40.

hash_set::gum

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

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

laatste
Positie net buiten het laatste element dat uit de hash_set is verwijderd.

sleutel
De sleutel van de elementen die uit de hash_set 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_set als er geen dergelijk element bestaat. Voor de functie derde lid is het aantal elementen dat uit de hash_set is verwijderd.

Opmerkingen

De lidfuncties genereren nooit een uitzondering.

Voorbeeld

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

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

int main()
{
    using namespace std;
    using namespace stdext;
    hash_set<int> hs1, hs2, hs3;
    hash_set<int>::iterator pIter, Iter1, Iter2;
    int i;
    hash_set<int>::size_type n;

    for (i = 1; i < 5; i++)
    {
        hs1.insert (i);
        hs2.insert (i * i);
        hs3.insert (i - 1);
    }

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

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

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

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

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

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

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

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

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

After the 2nd element is deleted, the hash_set hs1 is: 1 3 4.
After the middle two elements are deleted, the hash_set hs2 is: 16 4.
After the element with a key of 2 is deleted, the hash_set hs3 is: 0 1 3.
The number of elements removed from hs3 is: 1.
After another element (unique for hash_set) with a key
equal to that of the 2nd element is deleted, the hash_set hs3 is: 0 3.

hash_set::find

Retourneert een iterator die de locatie van een element in een hash_set 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 argumentsleutel die moet worden vergeleken met de sorteersleutel van een element uit de hash_set 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_set slaagt als er geen overeenkomst voor de sleutel wordt gevonden.

Opmerkingen

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

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

Voorbeeld

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

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_set <int> hs1;
   hash_set <int> :: const_iterator hs1_AcIter, hs1_RcIter;

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

   hs1_RcIter = hs1.find( 20 );
   cout << "The element of hash_set hs1 with a key of 20 is: "
        << *hs1_RcIter << "." << endl;

   hs1_RcIter = hs1.find( 40 );

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

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

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

hash_set::get_allocator

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

Allocator get_allocator() const;

Retourwaarde

De allocator die door de hash_set wordt gebruikt voor het beheren van geheugen. Dit is de sjabloonparameter Allocator.

Zie de sectie Opmerkingen van het onderwerp hash_set Klas voor meer informatie over Allocator.

Opmerkingen

Toewijzingen voor de hash_set-klasse geven aan hoe de klasse de 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_set_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_set <int, hash_compare <int, less<int> > > hs1;
   hash_set <int,  hash_compare <int, greater<int> > > hs2;
   hash_set <double, hash_compare <double,
      less<double> >, allocator<double> > hs3;

   hash_set <int, hash_compare <int,
      greater<int> > >::allocator_type hs2_Alloc;
   hash_set <double>::allocator_type hs3_Alloc;
   hs2_Alloc = hs2.get_allocator( );

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

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

   // The following lines create a hash_set hs4
   // with the allocator of hash_set hs1.
   hash_set <int>::allocator_type hs4_Alloc;
   hash_set <int> hs4;
   hs4_Alloc = hs2.get_allocator( );

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

hash_set::hash_set

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

hash_set();

explicit hash_set(
    const Traits& Comp);

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

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

hash_set(
    hash_set&& Right);

hash_set(
    initializer_list<Type> IList);

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

hash_set(
    initializer_list<value_type> IList,
    const Compare& Comp,
    const Allocator& Al);

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

template <class InputIterator>
hash_set(
    InputIterator First,
    InputIterator Last,
    const Traits& Comp);

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

Parameterwaarden

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

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

Rechts
De hash_set waarvan de geconstrueerde hash_set 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.

Opmerkingen

Alle constructors slaan een type allocatorobject op dat geheugenopslag voor de hash_set en die later kan worden geretourneerd door hash_set::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_sets.

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_set en die later kunnen worden geretourneerd door hash_set::key_comp aan te roepen. Zie het Traits voor meer informatie.

De eerste constructor maakt een lege initialen hash_set 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 type allocator (Al) dat moet worden gebruikt. Het sleutelwoord explicit onderdrukt bepaalde soorten automatische typeconversie.

De vierde en vijfde constructors geven een kopie van de hash_setRight.

De laatste zesde, zevende en achtste constructors gebruiken een initializer_list voor de elementen.

De laatste constructors kopiëren het bereik [ First, Last) van een hash_set met toenemende explicietheid bij het opgeven van het type vergelijkingsfunctie van klasseeigenschappen en allocator.

De achtste constructor verplaatst de hash_setRight.

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

hash_set::insert

Hiermee voegt u een element of een bereik van elementen in een hash_set.

pair<iterator, bool> insert(
    const value_type& Val);

iterator insert(
    iterator Where,
    const value_type& Val);

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

Parameterwaarden

Val
De waarde van een element dat moet worden ingevoegd in het hash_set element, tenzij het hash_set 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 _Where.)

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

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

IList
De initializer_list waaruit de elementen moeten worden gekopieerd.

Retourwaarde

De eerste insert lidfunctie retourneert een paar waarvan bool het onderdeel retourneert true als een invoeging is gemaakt en false of het hash_set al een element bevat waarvan de sleutel een equivalente waarde in de volgorde heeft en waarvan het iteratoronderdeel het adres retourneert waar een nieuw element is ingevoegd of waar het element zich al bevond.

Als u toegang wilt tot het iterator-onderdeel van een paar pr dat door deze lidfunctie wordt geretourneerd, gebruikt pr.first en deducteert u het *(pr.first). Als u toegang wilt krijgen tot het bool onderdeel van een paar pr dat door deze lidfunctie wordt geretourneerd, gebruikt pr.secondu en om het te deducteren.*(pr.second)

De functie tweede insert lid retourneert een iterator die verwijst naar de positie waar het nieuwe element is ingevoegd in de hash_set.

Opmerkingen

Met de functie derde lid worden de elementen in een initializer_list ingevoegd.

Met de functie derde lid wordt de volgorde van elementwaarden ingevoegd in een hash_set overeenkomstig element dat wordt geadresseerd door een iterator van het bereik [ First, Last) van een opgegeven hash_set.

hash_set::iterator

Een type dat een bidirectionele iterator biedt waarmee elk element in een hash_set 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 het begin van een voorbeeld van het declareren en gebruiken iteratorvan .

hash_set::key_comp

Hiermee wordt een kopie opgehaald van het hash-kenmerkobject dat wordt gebruikt voor hash- en orderelementsleutelwaarden in een hash_set.

key_compare key_comp() const;

Retourwaarde

Retourneert het functieobject dat een hash_set gebruikt om de elementen te ordenen. Dit is de sjabloonparameterEigenschappen.

Zie het onderwerp hash_set Klas voor meer informatie over eigenschappen.

Opmerkingen

Het opgeslagen object definieert de 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_set- en hash_multiset-klassen, waar ze identiek zijn, voor compatibiliteit met de hash_map- en hash_multimap-klassen, waar ze verschillend zijn.

Voorbeeld

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

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

   hash_set <int, hash_compare < int, less<int> > >hs1;
   hash_set<int, hash_compare < int, less<int> > >::key_compare kc1
          = hs1.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 hs1."
           << endl;
   }
   else
   {
      cout << "kc1( 2,3 ) returns value of false "
           << "where kc1 is the function object of hs1."
        << endl;
   }

   hash_set <int, hash_compare < int, greater<int> > > hs2;
   hash_set<int, hash_compare < int, greater<int> > >::key_compare
         kc2 = hs2.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 hs2."
           << endl;
   }
   else
   {
      cout << "kc2( 2,3 ) returns value of false, "
           << "where kc2 is the function object of hs2."
           << endl;
   }
}

hash_set::key_compare

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

typedef Traits key_compare;

Opmerkingen

key_compare is een synoniem voor de sjabloonparameter Traits.

Zie het onderwerp hash_set Klas voor meer informatie over eigenschappen.

Houd er rekening mee dat zowel key_compareals value_compare synoniemen zijn voor de sjabloonparameterEigenschappen. Beide typen worden geleverd voor de set- en multisetklassen, waar ze identiek zijn, voor compatibiliteit met de kaart- en multimapklassen, waar ze verschillend zijn.

Voorbeeld

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

hash_set::key_type

Een type dat een object beschrijft dat is opgeslagen als een element van een hash_set in de capaciteit als sorteersleutel.

typedef Key key_type;

Opmerkingen

key_type is een synoniem voor de parametersleutel van de sjabloon.

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

Houd er rekening mee dat zowel key_typeals value_type synoniemen zijn voor de parametersleutel van de sjabloon. 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 het voorbeeld voor value_type voor een voorbeeld van het declareren en gebruiken key_typevan .

hash_set::lower_bound

Retourneert een iterator naar het eerste element in een hash_set 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_set die wordt doorzocht.

Retourwaarde

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

Voorbeeld

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

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_set <int> hs1;
   hash_set <int> :: const_iterator hs1_AcIter, hs1_RcIter;

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

   hs1_RcIter = hs1.lower_bound( 20 );
   cout << "The element of hash_set hs1 with a key of 20 is: "
        << *hs1_RcIter << "." << endl;

   hs1_RcIter = hs1.lower_bound( 40 );

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

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

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

hash_set::max_size

Retourneert de maximale lengte van de hash_set.

size_type max_size() const;

Retourwaarde

De maximale lengte van de hash_set.

Voorbeeld

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

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_set <int> hs1;
   hash_set <int>::size_type i;

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

hash_set::operator=

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

hash_set& operator=(const hash_set& right);

hash_set& operator=(hash_set&& right);

Parameterwaarden

rechts
De hash_set worden gekopieerd naar de hash_set.

Opmerkingen

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

Voorbeeld

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

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_set<int> v1, v2, v3;
   hash_set<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_set::p ointer

Een type dat een aanwijzer biedt naar een element in een hash_set.

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_set-object.

hash_set::rbegin

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

const_reverse_iterator rbegin() const;

reverse_iterator rbegin();

Retourwaarde

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

Opmerkingen

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

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

rbegin kan worden gebruikt om een hash_set achterwaarts te doorlopen.

Voorbeeld

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

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_set <int> hs1;
   hash_set <int>::iterator hs1_Iter;
   hash_set <int>::reverse_iterator hs1_rIter;

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

   hs1_rIter = hs1.rbegin( );
   cout << "The first element in the reversed hash_set is "
        << *hs1_rIter << "." << endl;

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

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

   // A hash_set element can be erased by dereferencing to its key
   hs1_rIter = hs1.rbegin( );
   hs1.erase ( *hs1_rIter );

   hs1_rIter = hs1.rbegin( );
   cout << "After the erasure, the first element "
        << "in the reversed hash_set is "<< *hs1_rIter << "."
        << endl;
}

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

hash_set::reference

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

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

Voorbeeld

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

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_set <int> hs1;

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

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

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

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

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

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

hash_set::rend

Retourneert een iterator die de locatie adresseert die het laatste element in een omgekeerde hash_set 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_set slaagt (de locatie die voorafging aan het eerste element in de niet-omgedraaide hash_set).

Opmerkingen

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

Als de retourwaarde rend is toegewezen aan een const_reverse_iterator, kan het hash_set object niet worden gewijzigd. Als de retourwaarde rend is toegewezen aan een reverse_iterator, kan het hash_set 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_set heeft bereikt.

Voorbeeld

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

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_set <int> hs1;
   hash_set <int>::iterator hs1_Iter;
   hash_set <int>::reverse_iterator hs1_rIter;
   hash_set <int>::const_reverse_iterator hs1_crIter;

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

   hs1_rIter = hs1.rend( );
   hs1_rIter--;
   cout << "The last element in the reversed hash_set is "
        << *hs1_rIter << "." << endl;

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

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

   hs1_rIter = hs1.rend( );
   hs1_rIter--;
   hs1.erase ( *hs1_rIter );

   hs1_rIter = hs1.rend( );
   hs1_rIter--;
   cout << "After the erasure, the last element in the "
        << "reversed hash_set is " << *hs1_rIter << "."
        << endl;
}

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

hash_set::reverse_iterator

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

Voorbeeld

Zie het voorbeeld voor rbegin voor een voorbeeld van het declareren en gebruiken reverse_iteratorvan .

hash_set::size

Retourneert het aantal elementen in de hash_set.

size_type size() const;

Retourwaarde

De huidige lengte van het hash_set.

Voorbeeld

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

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_set <int> hs1;
   hash_set <int> :: size_type i;

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

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

The hash_set length is 1.
The hash_set length is now 2.

hash_set::size_type

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

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_set::wisselen

Uitwisseling van de elementen van twee hash_sets.

void swap(hash_set& right);

Parameterwaarden

rechts
Het argument hash_set de elementen op te geven die moeten worden gewisseld met de doel-hash_set.

Opmerkingen

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

Voorbeeld

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

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_set <int> hs1, hs2, hs3;
   hash_set <int>::iterator hs1_Iter;

   hs1.insert( 10 );
   hs1.insert( 20 );
   hs1.insert( 30 );
   hs2.insert( 100 );
   hs2.insert( 200 );
   hs3.insert( 300 );

   cout << "The original hash_set hs1 is:";
   for ( hs1_Iter = hs1.begin( ); hs1_Iter != hs1.end( );
         hs1_Iter++ )
         cout << " " << *hs1_Iter;
   cout   << "." << endl;

   // This is the member function version of swap
   hs1.swap( hs2 );

   cout << "After swapping with hs2, list hs1 is:";
   for ( hs1_Iter = hs1.begin( ); hs1_Iter != hs1.end( );
         hs1_Iter++ )
         cout << " " << *hs1_Iter;
   cout  << "." << endl;

   // This is the specialized template version of swap
   swap( hs1, hs3 );

   cout << "After swapping with hs3, list hs1 is:";
   for ( hs1_Iter = hs1.begin( ); hs1_Iter != hs1.end( );
         hs1_Iter++ )
         cout << " " << *hs1_Iter;
   cout   << "." << endl;
}

The original hash_set hs1 is: 10 20 30.
After swapping with hs2, list hs1 is: 200 100.
After swapping with hs3, list hs1 is: 300.

hash_set::upper_bound

Retourneert een iterator naar het eerste element in een hash_set dat 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_set die wordt doorzocht.

Retourwaarde

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

Voorbeeld

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

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_set <int> hs1;
   hash_set <int> :: const_iterator hs1_AcIter, hs1_RcIter;

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

   hs1_RcIter = hs1.upper_bound( 20 );
   cout << "The first element of hash_set hs1 with a key greater "
        << "than 20 is: " << *hs1_RcIter << "." << endl;

   hs1_RcIter = hs1.upper_bound( 30 );

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

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

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

hash_set::value_comp

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

value_compare value_comp() const;

Retourwaarde

Retourneert het functieobject dat een hash_set gebruikt om de elementen te ordenen. Dit is de sjabloonparameter Vergelijken.

Zie de sectie Opmerkingen van het onderwerp hash_set Klas voor meer informatie over Vergelijken.

Opmerkingen

Het opgeslagen object definieert de 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 value_compare alskey_compare synoniemen zijn voor de sjabloonparameter Vergelijken. 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

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

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

   hash_set <int, hash_compare < int, less<int> > > hs1;
   hash_set <int, hash_compare < int, less<int> >  >::value_compare
      vc1 = hs1.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 hs1."
           << endl;
   }
   else
   {
      cout << "vc1( 2,3 ) returns value of false, "
           << "where vc1 is the function object of hs1."
           << endl;
   }

   hash_set <int, hash_compare < int, greater<int> > > hs2;
   hash_set<int, hash_compare < int, greater<int> > >::value_compare
      vc2 = hs2.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 hs2."
           << endl;
   }
   else
   {
      cout << "vc2( 2,3 ) returns value of false, "
           << "where vc2 is the function object of hs2."
           << endl;
   }
}

hash_set::value_compare

Een type dat twee functieobjecten biedt, een binair predicaat van klassevergelijking waarmee twee elementwaarden van een hash_set 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_set 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 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 het voorbeeld voor value_comp voor een voorbeeld van het declareren en gebruiken value_comparevan .

hash_set::value_type

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

typedef Key value_type;

Voorbeeld

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

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_set <int> hs1;
   hash_set <int>::iterator hs1_Iter;

   hash_set <int> :: value_type hsvt_Int;   // Declare value_type
   hsvt_Int = 10;             // Initialize value_type

   hash_set <int> :: key_type hskt_Int;   // Declare key_type
   hskt_Int = 20;             // Initialize key_type

   hs1.insert( hsvt_Int );         // Insert value into hs1
   hs1.insert( hskt_Int );         // Insert key into hs1

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

The hash_set has elements: 10 20.

Zie ook

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