hash_set::hash_set
[!REMARQUE]
Cette API est obsolète.l'alternative est unordered_set Class.
Construit hash_set qui est vide ou qui est une copie de l'ensemble ou une partie d'un autre 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
);
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
);
hash_set(
hash_set&& _Right
);
Paramètres
Paramètre |
Description |
_Al |
La classe de l'allocateur de mémoire à utiliser pour cet objet d' hash_set , qui correspond par défaut à Allocator. |
_Comp |
La fonction de comparaison du type const Traits utilisée pour trier les éléments dans hash_set, qui correspond par défaut à hash_compare. |
_Right |
hash_set dont hash_set construit doit être une copie. |
_First |
Position du premier élément de la plage d'éléments à copier. |
_Last |
Position du premier élément au delà de la plage d'éléments à copier. |
Notes
Tous les constructeurs enregistre un type d'objet d'allocation qui gère la mémoire de mémoire pour hash_set et qui peut ensuite être retourné en appelant hash_set::get_allocator.Le paramètre de l'allocateur est souvent omis dans les déclarations de classe et les macros de prétraitement utilisées pour substituer d'autres allocateurs.
Tous les constructeurs initialisent leurs hash_sets.
Tous les constructeurs enregistre un objet de fonction de type Traits utilisé pour générer une commande entre les clés d' hash_set et qui peut ensuite être retourné en appelant hash_set::key_comp.Pour plus d'informations sur Traits consultez la rubrique de hash_set Class .
Les trois constructeurs suivants spécifient hash_setinitial vide, le deuxième spécifiant le type de fonction de comparaison (_Comp) à utiliser lorsque vous établissez l'ordre des éléments et du tiers spécifiant explicitement le type de l'allocateur (_Al) à utiliser.Le mot clé explicit supprimer certains genres de conversion de type automatique.
Le quatrième constructeur spécifie une copie d' hash_set_Right.
Les trois derniers constructeurs copiez la plage [_First, _Last) d' hash_set avec l'augmentation de l'explicité en spécifiant le type de fonction de comparaison des spécifications et de l'allocateur de classe.
Le dernier constructeur déplace hash_set_Right.
La commande réelle d'éléments dans un conteneur d' hash_set dépend de la fonction de hachage, de la fonction classante et la taille actuelle de la table de hachage et ne peut pas, comme prévu en général comme elle peut avec le conteneur de positionnement, où il a été déterminée par seule la fonction classante.
Exemple
// hash_set_hash_set.cpp
// compile with: /EHsc
#include <hash_set>
#include <iostream>
int main( )
{
using namespace std;
using namespace stdext;
hash_set <int>::iterator hs1_Iter, hs3_Iter, hs4_Iter,
hs5_Iter, hs6_Iter, hs7_Iter;
hash_set <int, hash_compare <int, greater<int> > >::iterator
hs2_Iter;
// Create an empty hash_set hs0 of key type integer
hash_set <int> hs0;
// Create an empty hash_set hs1 with the key comparison
// function of less than, then insert 4 elements
hash_set <int, hash_compare <int, less<int> > > hs1;
hs1.insert( 10 );
hs1.insert( 20 );
hs1.insert( 30 );
hs1.insert( 40 );
// Create an empty hash_set hs2 with the key comparison
// function of geater than, then insert 2 elements
hash_set <int, hash_compare <int, greater<int> > > hs2;
hs2.insert(10);
hs2.insert(20);
// Create a hash_set hs3 with the
// allocator of hash_set hs1
hash_set <int>::allocator_type hs1_Alloc;
hs1_Alloc = hs1.get_allocator( );
hash_set <int> hs3( hash_compare <int, less<int> >( ),
hs1_Alloc );
hs3.insert( 30 );
// Create a copy, hash_set hs4, of hash_set hs1
hash_set <int> hs4( hs1 );
// Create a hash_set hs5 by copying the range hs1[_First, _Last)
hash_set <int>::const_iterator hs1_bcIter, hs1_ecIter;
hs1_bcIter = hs1.begin( );
hs1_ecIter = hs1.begin( );
hs1_ecIter++;
hs1_ecIter++;
hash_set <int> hs5( hs1_bcIter, hs1_ecIter );
// Create a hash_set hs6 by copying the range hs4[_First, _Last)
// and with the allocator of hash_set hs2
hash_set <int>::allocator_type hs2_Alloc;
hs2_Alloc = hs2.get_allocator( );
hash_set <int> hs6( hs4.begin( ), ++hs4.begin( ),
less<int>( ), hs2_Alloc );
cout << "hs1 = ";
for ( hs1_Iter = hs1.begin( ); hs1_Iter != hs1.end( );
hs1_Iter++ )
cout << *hs1_Iter << " ";
cout << endl;
cout << "hs2 = " ;
for ( hs2_Iter = hs2.begin( ); hs2_Iter != hs2.end( );
hs2_Iter++ )
cout << *hs2_Iter << " ";
cout << endl;
cout << "hs3 = ";
for ( hs3_Iter = hs3.begin( ); hs3_Iter != hs3.end( );
hs3_Iter++ )
cout << *hs3_Iter << " ";
cout << endl;
cout << "hs4 = ";
for ( hs4_Iter = hs4.begin( ); hs4_Iter != hs4.end( );
hs4_Iter++ )
cout << *hs4_Iter << " ";
cout << endl;
cout << "hs5 = ";
for ( hs5_Iter = hs5.begin( ); hs5_Iter != hs5.end( );
hs5_Iter++ )
cout << *hs5_Iter << " ";
cout << endl;
cout << "hs6 = ";
for ( hs6_Iter = hs6.begin( ); hs6_Iter != hs6.end( );
hs6_Iter++ )
cout << *hs6_Iter << " ";
cout << endl;
// Create a copy, hash_set hs7, of hash_set hs1 by moving
hash_set <int, hash_compare <int, less<int> > >
hs7(move(hs1);
cout << "hs7 =";
for (hs7_Iter = hs7.begin(); hs7_Iter != hs7.end(); hs7_Iter++)
cout << " " << hs7_Iter -> second;
cout << endl;
}
Sortie
hs1 = 40 10 20 30
hs2 = 10 20
hs3 = 30
hs4 = 40 10 20 30
hs5 = 40 10
hs6 = 40
hs7 = 40 10 20 30
Configuration requise
en-tête : <hash_set>
Stdext del'espace de noms :