hash_multiset
(STL/CLR)
La classe de modèle décrit un objet qui contrôle une séquence d’éléments de longueur variable ayant un accès bidirectionnel. Vous utilisez le conteneur hash_multiset
pour gérer une séquence d’éléments en tant que table de hachage, chaque entrée de table stockant une liste liée bidirectionnelle de nœuds et chaque nœud stockant un élément. La valeur de chaque élément est utilisée comme clé pour classer la séquence.
Dans la description ci-dessous, GValue
est le même que , qui à son tour est le même que GKey
Key
si ce dernier est un type ref, auquel cas il s’agit Key^
.
template<typename Key>
ref class hash_multiset
: public
System::ICloneable,
System::Collections::IEnumerable,
System::Collections::ICollection,
System::Collections::Generic::IEnumerable<GValue>,
System::Collections::Generic::ICollection<GValue>,
System::Collections::Generic::IList<GValue>,
Microsoft::VisualC::StlClr::IHash<Gkey, GValue>
{ ..... };
Key
Type du composant clé d’un élément dans la séquence contrôlée.
Header :<cliext/hash_set>
Espace de noms : cliext
Définition de types | Description |
---|---|
hash_multiset::const_iterator |
Type d'un itérateur constant pour la séquence contrôlée. |
hash_multiset::const_reference |
Type d'une référence constante à un élément. |
hash_multiset::const_reverse_iterator |
Type d'un itérateur inserve constant pour la séquence contrôlée. |
hash_multiset::difference_type |
Type d’une distance (éventuellement signée) entre deux éléments. |
hash_multiset::generic_container |
Type de l’interface générique pour le conteneur. |
hash_multiset::generic_iterator |
Type d’itérateur pour l’interface générique du conteneur. |
hash_multiset::generic_reverse_iterator |
Type d’itérateur inverse pour l’interface générique du conteneur. |
hash_multiset::generic_value |
Type d’un élément pour l’interface générique du conteneur. |
hash_multiset::hasher |
Délégué de hachage pour une clé. |
hash_multiset::iterator |
Type d'un itérateur pour la séquence contrôlée. |
hash_multiset::key_compare |
Délégué de classement pour deux clés. |
hash_multiset::key_type |
Type d'une clé de tri. |
hash_multiset::reference |
Type d'une référence à un élément. |
hash_multiset::reverse_iterator |
Type d'un itérateur inverse pour la séquence contrôlée. |
hash_multiset::size_type |
Type d’une distance (non négative) entre deux éléments. |
hash_multiset::value_compare |
Délégué de classement pour deux valeurs d’élément. |
hash_multiset::value_type |
Type d’un élément. |
Fonction membre | Description |
---|---|
hash_multiset::begin |
Désigne le début de la séquence contrôlée. |
hash_multiset::bucket_count |
Compte le nombre de compartiments. |
hash_multiset::clear |
Supprime tous les éléments. |
hash_multiset::count |
Compte les éléments correspondant à une clé spécifiée. |
hash_multiset::empty |
Vérifie l'absence d'éléments. |
hash_multiset::end |
Désigne la fin de la séquence contrôlée. |
hash_multiset::equal_range |
Recherche une plage qui correspond à une clé spécifiée. |
hash_multiset::erase |
Supprime les éléments placés aux positions spécifiées. |
hash_multiset::find |
Recherche un élément qui correspond à une clé spécifiée. |
hash_multiset::hash_delegate |
Copie le délégué de hachage pour une clé. |
hash_multiset::hash_multiset |
Construit un objet conteneur. |
hash_multiset::insert |
Ajoute des éléments. |
hash_multiset::key_comp |
Copie le délégué de classement pour deux clés. |
hash_multiset::load_factor |
Compte le nombre moyen d'éléments par compartiment. |
hash_multiset::lower_bound |
Recherche le début de la plage qui correspond à une clé spécifiée. |
hash_multiset::make_value |
Construit un objet valeur. |
hash_multiset::max_load_factor |
Obtient ou définit le nombre maximal d’éléments par compartiment. |
hash_multiset::rbegin |
Désigne le début de la séquence contrôlée inverse. |
hash_multiset::rehash |
Régénère la table de hachage. |
hash_multiset::rend |
Désigne la fin de la séquence contrôlée inverse. |
hash_multiset::size |
Compte le nombre d'éléments. |
hash_multiset::swap |
Échange le contenu de deux conteneurs. |
hash_multiset::to_array |
Copie la séquence contrôlée dans un nouveau tableau. |
hash_multiset::upper_bound |
Recherche la fin de la plage qui correspond à une clé spécifiée. |
hash_multiset::value_comp |
Copie le délégué de classement pour deux valeurs d’élément. |
Opérateur | Description |
---|---|
hash_multiset::operator= |
Remplace la séquence contrôlée. |
Interface | Description |
---|---|
ICloneable | Dupliquer un objet. |
IEnumerable | Séquencer des éléments. |
ICollection | Conservez le groupe d’éléments. |
IEnumerable<T> | Séquence à l’aide d’éléments typés. |
ICollection<T> | Conservez le groupe d’éléments typés. |
IHash<Key, Value> |
Gérer le conteneur générique. |
L’objet alloue et libère le stockage pour la séquence qu’il contrôle en tant que nœuds individuels dans une liste liée bidirectionnelle. Pour accélérer l’accès, l’objet conserve également un tableau de pointeurs de longueur variable dans la liste (la table de hachage), gérant efficacement l’ensemble de la liste sous la forme d’une séquence de sous-listes ou de compartiments. Il insère des éléments dans un compartiment qu’il conserve ordonné en modifiant les liens entre les nœuds, jamais en copiant le contenu d’un nœud vers un autre. Cela signifie que vous pouvez insérer et supprimer librement des éléments sans déranger les éléments restants.
L’objet commande chaque compartiment qu’il contrôle en appelant un objet délégué stocké de type hash_set::key_compare
. Vous pouvez spécifier l’objet délégué stocké lorsque vous construisez le hash_set ; si vous ne spécifiez aucun objet délégué, la valeur par défaut est la comparaison operator<=(key_type, key_type)
.
Vous accédez à l’objet délégué stocké en appelant la fonction hash_set::key_comp
membre. Un tel objet délégué doit définir un ordre équivalent entre les clés de type hash_set::key_type
. Cela signifie que, pour deux clés X
et Y
:
key_comp()(X, Y)
retourne le même résultat booléen sur chaque appel.
Si key_comp()(X, Y) && key_comp()(Y, X)
c’est vrai, alors X
et Y
sont dits avoir un ordre équivalent.
Toute règle de classement qui se comporte comme operator<=(key_type, key_type)
, operator>=(key_type, key_type)
ou operator==(key_type, key_type)
définit l’ordre équivalent.
Le conteneur garantit uniquement que les éléments dont les clés ont un ordre équivalent (et qui se hachage à la même valeur entière) sont adjacents dans un compartiment. Contrairement à la classe hash_set
de modèle (STL/CLR), un objet de classe hash_multiset
de modèle ne nécessite pas que les clés pour tous les éléments soient uniques. (Deux clés ou plus peuvent avoir un ordre équivalent.)
L’objet détermine quel compartiment doit contenir une clé de classement donnée en appelant un objet délégué stocké de type hash_set::hasher
. Vous accédez à cet objet stocké en appelant la fonction hash_set::hash_delegate
membre pour obtenir une valeur entière qui dépend de la valeur de clé. Vous pouvez spécifier l’objet délégué stocké lorsque vous construisez le hash_set ; si vous spécifiez aucun objet délégué, la valeur par défaut est la fonction System::Object::hash_value(key_type)
. Cela signifie que, pour toutes les clés X
et Y
:
hash_delegate()(X)
retourne le même résultat entier sur chaque appel.
Si X
et Y
ont un ordre équivalent, il hash_delegate()(X)
doit retourner le même résultat entier que hash_delegate()(Y)
.
Chaque élément sert à la fois de clé et de valeur. La séquence est représentée de manière à permettre la recherche, l’insertion et la suppression d’un élément arbitraire en temps constant. Autrement dit, le nombre d’opérations est indépendant du nombre d’éléments de la séquence, au moins dans les meilleurs cas. En outre, l’insertion d’un élément invalide aucun itérateur et supprime un élément invalide uniquement les itérateurs qui pointent vers l’élément supprimé.
Si les valeurs hachées ne sont pas distribuées uniformément, toutefois, une table de hachage peut dégénérer. Dans l’extrême (pour une fonction de hachage qui retourne toujours la même valeur), la recherche, l’insertion et la suppression sont proportionnelles au nombre d’éléments de la séquence (temps linéaire). Le conteneur s’efforce de choisir une fonction de hachage raisonnable, une taille moyenne de compartiment et une taille de table de hachage (nombre total de compartiments), mais vous pouvez remplacer n’importe quel ou tous ces choix. Voir, par exemple, les fonctions hash_set::max_load_factor
et hash_set::rehash
.
Un hash_multiset
itérateur bidirectionnel prend en charge les itérateurs, ce qui signifie que vous pouvez passer à des éléments adjacents en fonction d’un itérateur qui désigne un élément dans la séquence contrôlée. Un nœud principal spécial correspond à l’itérateur retourné par hash_multiset::end
. Vous pouvez décrémenter cet itérateur pour atteindre le dernier élément de la séquence contrôlée, le cas échéant. Vous pouvez incrémenter un hash_multiset
itérateur pour atteindre le nœud principal, et il est ensuite comparé à end()
. Mais vous ne pouvez pas déréférencer l’itérateur retourné par end()
.
Vous ne pouvez pas faire référence à un hash_multiset
élément directement en fonction de sa position numérique. Cela nécessite un itérateur d’accès aléatoire.
Un hash_multiset
itérateur stocke un handle sur son nœud associé hash_multiset
, qui stocke à son tour un handle dans son conteneur associé. Vous pouvez utiliser des itérateurs uniquement avec leurs objets conteneur associés. Un hash_multiset
itérateur reste valide tant que son nœud associé hash_multiset
est associé à certains hash_multiset
. De plus, un itérateur valide est déreferencable. Vous pouvez l’utiliser pour accéder ou modifier la valeur de l’élément qu’elle désigne, tant qu’elle n’est pas égale à end()
.
L’effacement ou la suppression d’un élément appelle le destructeur pour sa valeur stockée. La destruction du conteneur efface tous les éléments. Ainsi, un conteneur dont le type d’élément est une classe ref garantit qu’aucun élément n’est hors service du conteneur. Toutefois, un conteneur de handles ne détruit pas ses éléments.
Désigne le début de la séquence contrôlée.
iterator begin();
La fonction membre retourne un itérateur bidirectionnel qui désigne le premier élément de la séquence contrôlée, ou juste au-delà de la fin d’une séquence vide. Vous l’utilisez pour obtenir un itérateur qui désigne le current
début de la séquence contrôlée, mais son état peut changer si la longueur de la séquence contrôlée change.
// cliext_hash_multiset_begin.cpp
// compile with: /clr
#include <cliext/hash_set>
typedef cliext::hash_multiset<wchar_t> Myhash_multiset;
int main()
{
Myhash_multiset c1;
c1.insert(L'a');
c1.insert(L'b');
c1.insert(L'c');
// display initial contents " a b c"
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// inspect first two items
Myhash_multiset::iterator it = c1.begin();
System::Console::WriteLine("*begin() = {0}", *it);
System::Console::WriteLine("*++begin() = {0}", *++it);
return (0);
}
a b c
*begin() = a
*++begin() = b
Compte le nombre de compartiments.
int bucket_count();
La fonction membre retourne le nombre actuel de comportements. Vous l’utilisez pour déterminer la taille de la table de hachage.
// cliext_hash_multiset_bucket_count.cpp
// compile with: /clr
#include <cliext/hash_set>
typedef cliext::hash_multiset<wchar_t> Myhash_multiset;
int main()
{
Myhash_multiset c1;
c1.insert(L'a');
c1.insert(L'b');
c1.insert(L'c');
// display initial contents " a b c"
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// inspect current parameters
System::Console::WriteLine("bucket_count() = {0}", c1.bucket_count());
System::Console::WriteLine("load_factor() = {0}", c1.load_factor());
System::Console::WriteLine("max_load_factor() = {0}",
c1.max_load_factor());
System::Console::WriteLine();
// change max_load_factor and redisplay
c1.max_load_factor(0.25f);
System::Console::WriteLine("bucket_count() = {0}", c1.bucket_count());
System::Console::WriteLine("load_factor() = {0}", c1.load_factor());
System::Console::WriteLine("max_load_factor() = {0}",
c1.max_load_factor());
System::Console::WriteLine();
// rehash and redisplay
c1.rehash(100);
System::Console::WriteLine("bucket_count() = {0}", c1.bucket_count());
System::Console::WriteLine("load_factor() = {0}", c1.load_factor());
System::Console::WriteLine("max_load_factor() = {0}",
c1.max_load_factor());
return (0);
}
a b c
bucket_count() = 16
load_factor() = 0.1875
max_load_factor() = 4
bucket_count() = 16
load_factor() = 0.1875
max_load_factor() = 0.25
bucket_count() = 128
load_factor() = 0.0234375
max_load_factor() = 0.25
Supprime tous les éléments.
void clear();
La fonction membre appelle erase(begin(), end())
efficacement . Vous l’utilisez pour vous assurer que la séquence contrôlée est vide.
// cliext_hash_multiset_clear.cpp
// compile with: /clr
#include <cliext/hash_set>
typedef cliext::hash_multiset<wchar_t> Myhash_multiset;
int main()
{
Myhash_multiset c1;
c1.insert(L'a');
c1.insert(L'b');
c1.insert(L'c');
// display initial contents " a b c"
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// clear the container and reinspect
c1.clear();
System::Console::WriteLine("size() = {0}", c1.size());
// add elements and clear again
c1.insert(L'a');
c1.insert(L'b');
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
c1.clear();
System::Console::WriteLine("size() = {0}", c1.size());
return (0);
}
a b c
size() = 0
a b
size() = 0
Type d'un itérateur constant pour la séquence contrôlée.
typedef T2 const_iterator;
Le type décrit un objet de type T2
non spécifié qui peut servir d’itérateur bidirectionnel constant pour la séquence contrôlée.
// cliext_hash_multiset_const_iterator.cpp
// compile with: /clr
#include <cliext/hash_set>
typedef cliext::hash_multiset<wchar_t> Myhash_multiset;
int main()
{
Myhash_multiset c1;
c1.insert(L'a');
c1.insert(L'b');
c1.insert(L'c');
// display contents " a b c"
Myhash_multiset::const_iterator cit = c1.begin();
for (; cit != c1.end(); ++cit)
System::Console::Write("{0} ", *cit);
System::Console::WriteLine();
return (0);
}
a b c
Type d'une référence constante à un élément.
typedef value_type% const_reference;
Le type décrit une référence constante à un élément.
// cliext_hash_multiset_const_reference.cpp
// compile with: /clr
#include <cliext/hash_set>
typedef cliext::hash_multiset<wchar_t> Myhash_multiset;
int main()
{
Myhash_multiset c1;
c1.insert(L'a');
c1.insert(L'b');
c1.insert(L'c');
// display initial contents " a b c"
Myhash_multiset::const_iterator cit = c1.begin();
for (; cit != c1.end(); ++cit)
{ // get a const reference to an element
Myhash_multiset::const_reference cref = *cit;
System::Console::Write("{0} ", cref);
}
System::Console::WriteLine();
return (0);
}
a b c
Type d'un itérateur inserve constant pour la séquence contrôlée.
typedef T4 const_reverse_iterator;
Le type décrit un objet de type T4
non spécifié qui peut servir d’itérateur inverse constant pour la séquence contrôlée.
// cliext_hash_multiset_const_reverse_iterator.cpp
// compile with: /clr
#include <cliext/hash_set>
typedef cliext::hash_multiset<wchar_t> Myhash_multiset;
int main()
{
Myhash_multiset c1;
c1.insert(L'a');
c1.insert(L'b');
c1.insert(L'c');
// display contents " a b c" reversed
Myhash_multiset::const_reverse_iterator crit = c1.rbegin();
for (; crit != c1.rend(); ++crit)
System::Console::Write("{0} ", *crit);
System::Console::WriteLine();
return (0);
}
c b a
Recherche le nombre d’éléments qui correspondent à une clé spécifiée.
size_type count(key_type key);
key
Valeur de clé à rechercher.
La fonction membre retourne le nombre d’éléments dans la séquence contrôlée qui ont un ordre équivalent avec key
. Vous l’utilisez pour déterminer le nombre d’éléments actuellement dans la séquence contrôlée qui correspondent à une clé spécifiée.
// cliext_hash_multiset_count.cpp
// compile with: /clr
#include <cliext/hash_set>
typedef cliext::hash_multiset<wchar_t> Myhash_multiset;
int main()
{
Myhash_multiset c1;
c1.insert(L'a');
c1.insert(L'b');
c1.insert(L'c');
// display initial contents " a b c"
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
System::Console::WriteLine("count(L'A') = {0}", c1.count(L'A'));
System::Console::WriteLine("count(L'b') = {0}", c1.count(L'b'));
System::Console::WriteLine("count(L'C') = {0}", c1.count(L'C'));
return (0);
}
a b c
count(L'A') = 0
count(L'b') = 1
count(L'C') = 0
Types d’une distance signée entre deux éléments.
typedef int difference_type;
Le type décrit un nombre d’éléments potentiellement négatif.
// cliext_hash_multiset_difference_type.cpp
// compile with: /clr
#include <cliext/hash_set>
typedef cliext::hash_multiset<wchar_t> Myhash_multiset;
int main()
{
Myhash_multiset c1;
c1.insert(L'a');
c1.insert(L'b');
c1.insert(L'c');
// display initial contents " a b c"
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// compute positive difference
Myhash_multiset::difference_type diff = 0;
for (Myhash_multiset::iterator it = c1.begin(); it != c1.end(); ++it)
++diff;
System::Console::WriteLine("end()-begin() = {0}", diff);
// compute negative difference
diff = 0;
for (Myhash_multiset::iterator it = c1.end(); it != c1.begin(); --it)
--diff;
System::Console::WriteLine("begin()-end() = {0}", diff);
return (0);
}
a b c
end()-begin() = 3
begin()-end() = -3
Vérifie l'absence d'éléments.
bool empty();
La fonction membre retourne la valeur true pour une séquence contrôlée vide. Cela équivaut à size() == 0
. Vous l’utilisez pour tester si la valeur hash_multiset
est vide.
// cliext_hash_multiset_empty.cpp
// compile with: /clr
#include <cliext/hash_set>
typedef cliext::hash_multiset<wchar_t> Myhash_multiset;
int main()
{
Myhash_multiset c1;
c1.insert(L'a');
c1.insert(L'b');
c1.insert(L'c');
// display initial contents " a b c"
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
System::Console::WriteLine("size() = {0}", c1.size());
System::Console::WriteLine("empty() = {0}", c1.empty());
// clear the container and reinspect
c1.clear();
System::Console::WriteLine("size() = {0}", c1.size());
System::Console::WriteLine("empty() = {0}", c1.empty());
return (0);
}
a b c
size() = 3
empty() = False
size() = 0
empty() = True
Désigne la fin de la séquence contrôlée.
iterator end();
La fonction membre retourne un itérateur bidirectionnel qui pointe juste au-delà de la fin de la séquence contrôlée. Vous l’utilisez pour obtenir un itérateur qui désigne la fin de la séquence contrôlée ; son état ne change pas si la longueur de la séquence contrôlée change.
// cliext_hash_multiset_end.cpp
// compile with: /clr
#include <cliext/hash_set>
typedef cliext::hash_multiset<wchar_t> Myhash_multiset;
int main()
{
Myhash_multiset c1;
c1.insert(L'a');
c1.insert(L'b');
c1.insert(L'c');
// display initial contents " a b c"
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// inspect last two items
Myhash_multiset::iterator it = c1.end();
--it;
System::Console::WriteLine("*-- --end() = {0}", *--it);
System::Console::WriteLine("*--end() = {0}", *++it);
return (0);
}
a b c
*-- --end() = b
*--end() = c
Recherche une plage qui correspond à une clé spécifiée.
cliext::pair<iterator, iterator> equal_range(key_type key);
key
Valeur de clé à rechercher.
La fonction membre retourne une paire d’itérateurs cliext::pair<iterator, iterator>(lower_bound(key), upper_bound(key))
. Vous l’utilisez pour déterminer la plage d’éléments actuellement dans la séquence contrôlée qui correspond à une clé spécifiée.
// cliext_hash_multiset_equal_range.cpp
// compile with: /clr
#include <cliext/hash_set>
typedef cliext::hash_multiset<wchar_t> Myhash_multiset;
typedef Myhash_multiset::pair_iter_iter Pairii;
int main()
{
Myhash_multiset c1;
c1.insert(L'a');
c1.insert(L'b');
c1.insert(L'c');
// display initial contents " a b c"
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// display results of failed search
Pairii pair1 = c1.equal_range(L'x');
System::Console::WriteLine("equal_range(L'x') empty = {0}",
pair1.first == pair1.second);
// display results of successful search
pair1 = c1.equal_range(L'b');
for (; pair1.first != pair1.second; ++pair1.first)
System::Console::Write("{0} ", *pair1.first);
System::Console::WriteLine();
return (0);
}
a b c
equal_range(L'x') empty = True
b
Supprime les éléments placés aux positions spécifiées.
iterator erase(iterator where);
iterator erase(iterator first, iterator last);
bool erase(key_type key)
first
Début de la plage à effacer.
key
Valeur de clé à effacer.
last
Fin de la plage à effacer.
where
Élément à effacer.
La première fonction membre supprime l’élément de la séquence contrôlée pointée par where
, et retourne un itérateur qui désigne le premier élément restant au-delà de l’élément supprimé, ou end()
s’il n’existe aucun élément de ce type. Vous l’utilisez pour supprimer un seul élément.
La deuxième fonction membre supprime les éléments de la séquence contrôlée dans la plage [first
, last
), et retourne un itérateur qui désigne le premier élément restant au-delà des éléments supprimés, ou end()
s’il n’existe aucun élément de ce type. Vous l’utilisez pour supprimer zéro ou plusieurs éléments contigus.
La troisième fonction membre supprime tout élément de la séquence contrôlée dont la clé a un ordre équivalent et key
retourne le nombre d’éléments supprimés. Vous l’utilisez pour supprimer et compter tous les éléments qui correspondent à une clé spécifiée.
Chaque effacement d’élément prend du temps proportionnel au logarithme du nombre d’éléments dans la séquence contrôlée.
// cliext_hash_multiset_erase.cpp
// compile with: /clr
#include <cliext/hash_set>
typedef cliext::hash_multiset<wchar_t> Myhash_multiset;
int main()
{
Myhash_multiset c1;
c1.insert(L'a');
c1.insert(L'b');
c1.insert(L'c');
// display initial contents " a b c"
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// erase an element and reinspect
System::Console::WriteLine("erase(begin()) = {0}",
*c1.erase(c1.begin()));
// add elements and display " b c d e"
c1.insert(L'd');
c1.insert(L'e');
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// erase all but end
Myhash_multiset::iterator it = c1.end();
System::Console::WriteLine("erase(begin(), end()-1) = {0}",
*c1.erase(c1.begin(), --it));
System::Console::WriteLine("size() = {0}", c1.size());
return (0);
}
a b c
erase(begin()) = b
b c d e
erase(begin(), end()-1) = e
size() = 1
Recherche un élément qui correspond à une clé spécifiée.
iterator find(key_type key);
key
Valeur de clé à rechercher.
Si au moins un élément de la séquence contrôlée a un ordre équivalent avec key
, la fonction membre retourne un itérateur désignant l’un de ces éléments ; sinon, il retourne end()
. Vous l’utilisez pour localiser un élément actuellement dans la séquence contrôlée qui correspond à une clé spécifiée.
// cliext_hash_multiset_find.cpp
// compile with: /clr
#include <cliext/hash_set>
typedef cliext::hash_multiset<wchar_t> Myhash_multiset;
int main()
{
Myhash_multiset c1;
c1.insert(L'a');
c1.insert(L'b');
c1.insert(L'c');
// display initial contents " a b c"
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
System::Console::WriteLine("find {0} = {1}",
L'A', c1.find(L'A') != c1.end());
System::Console::WriteLine("find {0} = {1}",
L'b', *c1.find(L'b'));
System::Console::WriteLine("find {0} = {1}",
L'C', c1.find(L'C') != c1.end());
return (0);
}
a b c
find A = False
find b = b
find C = False
Type de l’interface générique pour le conteneur.
typedef Microsoft::VisualC::StlClr::
IHash<GKey, GValue>
generic_container;
Le type décrit l’interface générique pour cette classe de conteneur de modèle.
// cliext_hash_multiset_generic_container.cpp
// compile with: /clr
#include <cliext/hash_set>
typedef cliext::hash_multiset<wchar_t> Myhash_multiset;
int main()
{
Myhash_multiset c1;
c1.insert(L'a');
c1.insert(L'b');
c1.insert(L'c');
// display contents " a b c"
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// construct a generic container
Myhash_multiset::generic_container^ gc1 = %c1;
for each (wchar_t elem in gc1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// modify generic and display original
gc1->insert(L'd');
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// modify original and display generic
c1.insert(L'e');
for each (wchar_t elem in gc1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
return (0);
}
a b c
a b c
a b c d
a b c d e
Type d’itérateur à utiliser avec l’interface générique du conteneur.
typedef Microsoft::VisualC::StlClr::Generic::
ContainerBidirectionalIterator<generic_value>
generic_iterator;
Le type décrit un itérateur générique qui peut être utilisé avec l’interface générique pour cette classe de conteneur de modèle.
// cliext_hash_multiset_generic_iterator.cpp
// compile with: /clr
#include <cliext/hash_set>
typedef cliext::hash_multiset<wchar_t> Myhash_multiset;
int main()
{
Myhash_multiset c1;
c1.insert(L'a');
c1.insert(L'b');
c1.insert(L'c');
// display contents " a b c"
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// construct a generic container
Myhash_multiset::generic_container^ gc1 = %c1;
for each (wchar_t elem in gc1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// get an element and display it
Myhash_multiset::generic_iterator gcit = gc1->begin();
Myhash_multiset::generic_value gcval = *gcit;
System::Console::WriteLine("{0} ", gcval);
return (0);
}
a b c
a b c
a
Type d’itérateur inverse à utiliser avec l’interface générique du conteneur.
typedef Microsoft::VisualC::StlClr::Generic::
ReverseRandomAccessIterator<generic_value>
generic_reverse_iterator;
Le type décrit un itérateur inverse générique qui peut être utilisé avec l’interface générique pour cette classe de conteneur de modèle.
// cliext_hash_multiset_generic_reverse_iterator.cpp
// compile with: /clr
#include <cliext/hash_set>
typedef cliext::hash_multiset<wchar_t> Myhash_multiset;
int main()
{
Myhash_multiset c1;
c1.insert(L'a');
c1.insert(L'b');
c1.insert(L'c');
// display contents " a b c"
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// construct a generic container
Myhash_multiset::generic_container^ gc1 = %c1;
for each (wchar_t elem in gc1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// get an element and display it
Myhash_multiset::generic_reverse_iterator gcit = gc1->rbegin();
Myhash_multiset::generic_value gcval = *gcit;
System::Console::WriteLine("{0} ", gcval);
return (0);
}
a b c
a b c
c
Type d’un élément à utiliser avec l’interface générique du conteneur.
typedef GValue generic_value;
Le type décrit un objet de type GValue
qui décrit la valeur de l’élément stocké à utiliser avec l’interface générique pour cette classe de conteneur de modèle.
// cliext_hash_multiset_generic_value.cpp
// compile with: /clr
#include <cliext/hash_set>
typedef cliext::hash_multiset<wchar_t> Myhash_multiset;
int main()
{
Myhash_multiset c1;
c1.insert(L'a');
c1.insert(L'b');
c1.insert(L'c');
// display contents " a b c"
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// construct a generic container
Myhash_multiset::generic_container^ gc1 = %c1;
for each (wchar_t elem in gc1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// get an element and display it
Myhash_multiset::generic_iterator gcit = gc1->begin();
Myhash_multiset::generic_value gcval = *gcit;
System::Console::WriteLine("{0} ", gcval);
return (0);
}
a b c
a b c
a
Recherche un élément qui correspond à une clé spécifiée.
hasher^ hash_delegate();
La fonction membre retourne le délégué utilisé pour convertir une valeur de clé en entier. Vous l’utilisez pour hacher une clé.
// cliext_hash_multiset_hash_delegate.cpp
// compile with: /clr
#include <cliext/hash_set>
typedef cliext::hash_multiset<wchar_t> Myhash_multiset;
int main()
{
Myhash_multiset c1;
Myhash_multiset::hasher^ myhash = c1.hash_delegate();
System::Console::WriteLine("hash(L'a') = {0}", myhash(L'a'));
System::Console::WriteLine("hash(L'b') = {0}", myhash(L'b'));
return (0);
}
hash(L'a') = 1616896120
hash(L'b') = 570892832
Construit un objet conteneur.
hash_multiset();
explicit hash_multiset(key_compare^ pred);
hash_multiset(key_compare^ pred, hasher^ hashfn);
hash_multiset(hash_multiset<Key>% right);
hash_multiset(hash_multiset<Key>^ right);
template<typename InIter>
hash_multiset(InIter first, InIter last);
template<typename InIter>
hash_multiset(InIter first, InIter last,
key_compare^ pred);
template<typename InIter>
hash_multiset(InIter first, InIter last,
key_compare^ pred, hasher^ hashfn);
hash_multiset(System::Collections::Generic::IEnumerable<GValue>^ right);
hash_multiset(System::Collections::Generic::IEnumerable<GValue>^ right,
key_compare^ pred);
hash_multiset(System::Collections::Generic::IEnumerable<GValue>^ right,
key_compare^ pred, hasher^ hashfn);
first
Début de la plage à insérer.
hashfn
Fonction de hachage pour le mappage des clés aux compartiments.
last
Fin de la plage à insérer.
pred
Classement du prédicat pour la séquence contrôlée.
right
Objet ou plage à insérer.
Constructeur :
hash_multiset();
initialise la séquence contrôlée sans éléments, avec le prédicat key_compare()
de classement par défaut et la fonction de hachage par défaut. Vous l’utilisez pour spécifier une séquence contrôlée initiale vide, avec le prédicat de classement par défaut et la fonction de hachage.
Constructeur :
explicit hash_multiset(key_compare^ pred);
initialise la séquence contrôlée sans éléments, avec le prédicat pred
de classement et avec la fonction de hachage par défaut. Vous l’utilisez pour spécifier une séquence contrôlée initiale vide, avec le prédicat de classement spécifié et la fonction de hachage par défaut.
Constructeur :
hash_multiset(key_compare^ pred, hasher^ hashfn);
initialise la séquence contrôlée sans éléments, avec le prédicat pred
de classement et avec la fonction hashfn
de hachage. Vous l’utilisez pour spécifier une séquence contrôlée initiale vide, avec le prédicat de classement et la fonction de hachage spécifiés.
Constructeur :
hash_multiset(hash_multiset<Key>% right);
initialise la séquence contrôlée avec la séquence [right.begin()
, right.end()
), avec le prédicat de classement par défaut et avec la fonction de hachage par défaut. Vous l’utilisez pour spécifier une séquence contrôlée initiale qui est une copie de la séquence contrôlée par l’objet hash_multiset
right
, avec le prédicat de classement par défaut et la fonction de hachage.
Constructeur :
hash_multiset(hash_multiset<Key>^ right);
initialise la séquence contrôlée avec la séquence [right->begin()
, right->end()
), avec le prédicat de classement par défaut et avec la fonction de hachage par défaut. Vous l’utilisez pour spécifier une séquence contrôlée initiale qui est une copie de la séquence contrôlée par l’objet hash_multiset
right
, avec le prédicat de classement par défaut et la fonction de hachage.
Constructeur :
template<typename InIter> hash_multiset(InIter first, InIter last);
initialise la séquence contrôlée avec la séquence [first
, last
), avec le prédicat de classement par défaut et avec la fonction de hachage par défaut. Vous l’utilisez pour rendre la séquence contrôlée une copie d’une autre séquence, avec le prédicat de classement par défaut et la fonction de hachage.
Constructeur :
template<typename InIter> hash_multiset(InIter first, InIter last, key_compare^ pred);
initialise la séquence contrôlée avec la séquence [first
, last
), avec le prédicat pred
de classement et avec la fonction de hachage par défaut. Vous l’utilisez pour rendre la séquence contrôlée une copie d’une autre séquence, avec le prédicat de classement spécifié et la fonction de hachage par défaut.
Constructeur :
template<typename InIter> hash_multiset(InIter first, InIter last, key_compare^ pred, hasher^ hashfn);
initialise la séquence contrôlée avec la séquence [first
, last
), avec le prédicat pred
de classement et avec la fonction hashfn
de hachage . Vous l’utilisez pour faire de la séquence contrôlée une copie d’une autre séquence, avec le prédicat de classement et la fonction de hachage spécifiés.
Constructeur :
hash_multiset(System::Collections::Generic::IEnumerable<Key>^ right);
initialise la séquence contrôlée avec la séquence désignée par l’énumérateur right
, avec le prédicat de classement par défaut et avec la fonction de hachage par défaut. Vous l’utilisez pour rendre la séquence contrôlée une copie d’une autre séquence décrite par un énumérateur, avec le prédicat de classement par défaut et la fonction de hachage.
Constructeur :
hash_multiset(System::Collections::Generic::IEnumerable<Key>^ right, key_compare^ pred);
initialise la séquence contrôlée avec la séquence désignée par l’énumérateur right
, avec le prédicat pred
de classement et avec la fonction de hachage par défaut. Vous l’utilisez pour rendre la séquence contrôlée une copie d’une autre séquence décrite par un énumérateur, avec le prédicat de classement spécifié et la fonction de hachage par défaut.
Constructeur :
hash_multiset(System::Collections::Generic::IEnumerable<Key>^ right, key_compare^ pred, hasher^ hashfn);
initialise la séquence contrôlée avec la séquence désignée par l’énumérateur right
, avec le prédicat pred
de classement et avec la fonction hashfn
de hachage . Vous l’utilisez pour rendre la séquence contrôlée une copie d’une autre séquence décrite par un énumérateur, avec le prédicat de classement et la fonction de hachage spécifiés.
// cliext_hash_multiset_construct.cpp
// compile with: /clr
#include <cliext/hash_set>
int myfun(wchar_t key)
{ // hash a key
return (key ^ 0xdeadbeef);
}
typedef cliext::hash_multiset<wchar_t> Myhash_multiset;
int main()
{
// construct an empty container
Myhash_multiset c1;
System::Console::WriteLine("size() = {0}", c1.size());
c1.insert(L'a');
c1.insert(L'b');
c1.insert(L'c');
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// construct with an ordering rule
Myhash_multiset c2 = cliext::greater_equal<wchar_t>();
System::Console::WriteLine("size() = {0}", c2.size());
c2.insert(c1.begin(), c1.end());
for each (wchar_t elem in c2)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// construct with an ordering rule and hash function
Myhash_multiset c2h(cliext::greater_equal<wchar_t>(),
gcnew Myhash_multiset::hasher(&myfun));
System::Console::WriteLine("size() = {0}", c2h.size());
c2h.insert(c1.begin(), c1.end());
for each (wchar_t elem in c2h)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
System::Console::WriteLine();
// construct with an iterator range
Myhash_multiset c3(c1.begin(), c1.end());
for each (wchar_t elem in c3)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// construct with an iterator range and an ordering rule
Myhash_multiset c4(c1.begin(), c1.end(),
cliext::greater_equal<wchar_t>());
for each (wchar_t elem in c4)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// construct with an iterator range and an ordering rule and hash function
Myhash_multiset c4h(c1.begin(), c1.end(),
cliext::greater_equal<wchar_t>(),
gcnew Myhash_multiset::hasher(&myfun));
for each (wchar_t elem in c4h)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
System::Console::WriteLine();
// construct with an enumeration
Myhash_multiset c5( // NOTE: cast is not needed
(System::Collections::Generic::IEnumerable<wchar_t>^)%c3);
for each (wchar_t elem in c5)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// construct with an enumeration and an ordering rule
Myhash_multiset c6( // NOTE: cast is not needed
(System::Collections::Generic::IEnumerable<wchar_t>^)%c3,
cliext::greater_equal<wchar_t>());
for each (wchar_t elem in c6)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// construct with an enumeration and an ordering rule and hash function
Myhash_multiset c6h( // NOTE: cast is not needed
(System::Collections::Generic::IEnumerable<wchar_t>^)%c3,
cliext::greater_equal<wchar_t>(),
gcnew Myhash_multiset::hasher(&myfun));
for each (wchar_t elem in c6h)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
System::Console::WriteLine();
// construct from a generic container
Myhash_multiset c7(c4);
for each (wchar_t elem in c7)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// construct by copying another container
Myhash_multiset c8(%c3);
for each (wchar_t elem in c8)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
return (0);
}
size() = 0
a b c
size() = 0
a b c
size() = 0
c b a
a b c
a b c
c b a
a b c
a b c
c b a
a b c
a b c
Délégué de hachage pour une clé.
Microsoft::VisualC::StlClr::UnaryDelegate<GKey, int>
hasher;
Le type décrit un délégué qui convertit une valeur de clé en entier.
// cliext_hash_multiset_hasher.cpp
// compile with: /clr
#include <cliext/hash_set>
typedef cliext::hash_multiset<wchar_t> Myhash_multiset;
int main()
{
Myhash_multiset c1;
Myhash_multiset::hasher^ myhash = c1.hash_delegate();
System::Console::WriteLine("hash(L'a') = {0}", myhash(L'a'));
System::Console::WriteLine("hash(L'b') = {0}", myhash(L'b'));
return (0);
}
hash(L'a') = 1616896120
hash(L'b') = 570892832
Ajoute des éléments.
iterator insert(value_type val);
iterator insert(iterator where, value_type val);
template<typename InIter>
void insert(InIter first, InIter last);
void insert(System::Collections::Generic::IEnumerable<value_type>^ right);
first
Début de la plage à insérer.
last
Fin de la plage à insérer.
right
Énumération à insérer.
val
Valeur de clé à insérer.
where
Où dans le conteneur insérer (indicateur uniquement).
Chacune des fonctions membres insère une séquence spécifiée par les opérandes restants.
La première fonction membre insère un élément avec valeur val
et retourne un itérateur qui désigne l’élément nouvellement inséré. Vous l’utilisez pour insérer un seul élément.
La deuxième fonction membre insère un élément avec une valeur val
, en utilisant where
comme indicateur (pour améliorer les performances) et retourne un itérateur qui désigne l’élément nouvellement inséré. Vous l’utilisez pour insérer un élément unique qui peut être à côté d’un élément que vous connaissez.
La troisième fonction membre insère la séquence [first
, last
). Vous l’utilisez pour insérer zéro ou plusieurs éléments copiés à partir d’une autre séquence.
La quatrième fonction membre insère la séquence désignée par le right
. Vous l’utilisez pour insérer une séquence décrite par un énumérateur.
Chaque insertion d’élément prend du temps proportionnelle au logarithme du nombre d’éléments dans la séquence contrôlée. L’insertion peut se produire en temps constant amorti, toutefois, en fonction d’un indicateur qui désigne un élément en regard du point d’insertion.
// cliext_hash_multiset_insert.cpp
// compile with: /clr
#include <cliext/hash_set>
typedef cliext::hash_multiset<wchar_t> Myhash_multiset;
int main()
{
Myhash_multiset c1;
c1.insert(L'a');
c1.insert(L'b');
c1.insert(L'c');
// display initial contents " a b c"
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// insert a single value, unique and duplicate
System::Console::WriteLine("insert(L'x') = {0}",
*c1.insert(L'x'));
System::Console::WriteLine("insert(L'b') = {0}",
*c1.insert(L'b'));
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// insert a single value with hint
System::Console::WriteLine("insert(begin(), L'y') = {0}",
*c1.insert(c1.begin(), L'y'));
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// insert an iterator range
Myhash_multiset c2;
Myhash_multiset::iterator it = c1.end();
c2.insert(c1.begin(), --it);
for each (wchar_t elem in c2)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// insert an enumeration
Myhash_multiset c3;
c3.insert( // NOTE: cast is not needed
(System::Collections::Generic::IEnumerable<wchar_t>^)%c1);
for each (wchar_t elem in c3)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
return (0);
}
a b c
insert(L'x') = x
insert(L'b') = b
a b b c x
insert(begin(), L'y') = y
a b b c x y
a b b c x
a b b c x y
Type d'un itérateur pour la séquence contrôlée.
typedef T1 iterator;
Le type décrit un objet de type T1
non spécifié qui peut servir d’itérateur bidirectionnel pour la séquence contrôlée.
// cliext_hash_multiset_iterator.cpp
// compile with: /clr
#include <cliext/hash_set>
typedef cliext::hash_multiset<wchar_t> Myhash_multiset;
int main()
{
Myhash_multiset c1;
c1.insert(L'a');
c1.insert(L'b');
c1.insert(L'c');
// display contents " a b c"
Myhash_multiset::iterator it = c1.begin();
for (; it != c1.end(); ++it)
System::Console::Write("{0} ", *it);
System::Console::WriteLine();
return (0);
}
a b c
Copie le délégué de classement pour deux clés.
key_compare^key_comp();
La fonction membre retourne le délégué de classement utilisé pour commander la séquence contrôlée. Vous l’utilisez pour comparer deux clés.
// cliext_hash_multiset_key_comp.cpp
// compile with: /clr
#include <cliext/hash_set>
typedef cliext::hash_multiset<wchar_t> Myhash_multiset;
int main()
{
Myhash_multiset c1;
Myhash_multiset::key_compare^ kcomp = c1.key_comp();
System::Console::WriteLine("compare(L'a', L'a') = {0}",
kcomp(L'a', L'a'));
System::Console::WriteLine("compare(L'a', L'b') = {0}",
kcomp(L'a', L'b'));
System::Console::WriteLine("compare(L'b', L'a') = {0}",
kcomp(L'b', L'a'));
System::Console::WriteLine();
// test a different ordering rule
Myhash_multiset c2 = cliext::greater<wchar_t>();
kcomp = c2.key_comp();
System::Console::WriteLine("compare(L'a', L'a') = {0}",
kcomp(L'a', L'a'));
System::Console::WriteLine("compare(L'a', L'b') = {0}",
kcomp(L'a', L'b'));
System::Console::WriteLine("compare(L'b', L'a') = {0}",
kcomp(L'b', L'a'));
return (0);
}
compare(L'a', L'a') = True
compare(L'a', L'b') = True
compare(L'b', L'a') = False
compare(L'a', L'a') = False
compare(L'a', L'b') = False
compare(L'b', L'a') = True
Délégué de classement pour deux clés.
Microsoft::VisualC::StlClr::BinaryDelegate<GKey, GKey, bool>
key_compare;
Le type est un synonyme du délégué qui détermine l’ordre de ses arguments clés.
// cliext_hash_multiset_key_compare.cpp
// compile with: /clr
#include <cliext/hash_set>
typedef cliext::hash_multiset<wchar_t> Myhash_multiset;
int main()
{
Myhash_multiset c1;
Myhash_multiset::key_compare^ kcomp = c1.key_comp();
System::Console::WriteLine("compare(L'a', L'a') = {0}",
kcomp(L'a', L'a'));
System::Console::WriteLine("compare(L'a', L'b') = {0}",
kcomp(L'a', L'b'));
System::Console::WriteLine("compare(L'b', L'a') = {0}",
kcomp(L'b', L'a'));
System::Console::WriteLine();
// test a different ordering rule
Myhash_multiset c2 = cliext::greater<wchar_t>();
kcomp = c2.key_comp();
System::Console::WriteLine("compare(L'a', L'a') = {0}",
kcomp(L'a', L'a'));
System::Console::WriteLine("compare(L'a', L'b') = {0}",
kcomp(L'a', L'b'));
System::Console::WriteLine("compare(L'b', L'a') = {0}",
kcomp(L'b', L'a'));
return (0);
}
compare(L'a', L'a') = True
compare(L'a', L'b') = True
compare(L'b', L'a') = False
compare(L'a', L'a') = False
compare(L'a', L'b') = False
compare(L'b', L'a') = True
Type d'une clé de tri.
typedef Key key_type;
Le type est un synonyme du paramètre de modèle Key
.
// cliext_hash_multiset_key_type.cpp
// compile with: /clr
#include <cliext/hash_set>
typedef cliext::hash_multiset<wchar_t> Myhash_multiset;
int main()
{
Myhash_multiset c1;
c1.insert(L'a');
c1.insert(L'b');
c1.insert(L'c');
// display contents " a b c" using key_type
for (Myhash_multiset::iterator it = c1.begin(); it != c1.end(); ++it)
{ // store element in key_type object
Myhash_multiset::key_type val = *it;
System::Console::Write("{0} ", val);
}
System::Console::WriteLine();
return (0);
}
a b c
Compte le nombre moyen d'éléments par compartiment.
float load_factor();
La fonction membre retourne (float)size() / count()
. Vous l’utilisez pour déterminer la taille moyenne du compartiment.
// cliext_hash_multiset_load_factor.cpp
// compile with: /clr
#include <cliext/hash_set>
typedef cliext::hash_multiset<wchar_t> Myhash_multiset;
int main()
{
Myhash_multiset c1;
c1.insert(L'a');
c1.insert(L'b');
c1.insert(L'c');
// display initial contents " a b c"
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// inspect current parameters
System::Console::WriteLine("bucket_count() = {0}", c1.bucket_count());
System::Console::WriteLine("load_factor() = {0}", c1.load_factor());
System::Console::WriteLine("max_load_factor() = {0}",
c1.max_load_factor());
System::Console::WriteLine();
// change max_load_factor and redisplay
c1.max_load_factor(0.25f);
System::Console::WriteLine("bucket_count() = {0}", c1.bucket_count());
System::Console::WriteLine("load_factor() = {0}", c1.load_factor());
System::Console::WriteLine("max_load_factor() = {0}",
c1.max_load_factor());
System::Console::WriteLine();
// rehash and redisplay
c1.rehash(100);
System::Console::WriteLine("bucket_count() = {0}", c1.bucket_count());
System::Console::WriteLine("load_factor() = {0}", c1.load_factor());
System::Console::WriteLine("max_load_factor() = {0}",
c1.max_load_factor());
return (0);
}
a b c
bucket_count() = 16
load_factor() = 0.1875
max_load_factor() = 4
bucket_count() = 16
load_factor() = 0.1875
max_load_factor() = 0.25
bucket_count() = 128
load_factor() = 0.0234375
max_load_factor() = 0.25
Recherche le début de la plage qui correspond à une clé spécifiée.
iterator lower_bound(key_type key);
key
Valeur de clé à rechercher.
La fonction membre détermine le premier élément X
de la séquence contrôlée qui hachage dans le même compartiment que key
et a un ordre équivalent à key
. Si aucun élément de ce type n’existe, il retourne end()
; sinon, il retourne un itérateur qui désigne X
. Vous l’utilisez pour localiser le début d’une séquence d’éléments actuellement dans la séquence contrôlée qui correspond à une clé spécifiée.
// cliext_hash_multiset_lower_bound.cpp
// compile with: /clr
#include <cliext/hash_set>
typedef cliext::hash_multiset<wchar_t> Myhash_multiset;
int main()
{
Myhash_multiset c1;
c1.insert(L'a');
c1.insert(L'b');
c1.insert(L'c');
// display initial contents " a b c"
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
System::Console::WriteLine("lower_bound(L'x')==end() = {0}",
c1.lower_bound(L'x') == c1.end());
System::Console::WriteLine("*lower_bound(L'a') = {0}",
*c1.lower_bound(L'a'));
System::Console::WriteLine("*lower_bound(L'b') = {0}",
*c1.lower_bound(L'b'));
return (0);
}
a b c
lower_bound(L'x')==end() = True
*lower_bound(L'a') = a
*lower_bound(L'b') = b
Construit un objet valeur.
static value_type make_value(key_type key);
key
Valeur de clé à utiliser.
La fonction membre retourne un value_type
objet dont la clé est key
. Vous l’utilisez pour composer un objet adapté à une utilisation avec plusieurs autres fonctions membres.
// cliext_hash_multiset_make_value.cpp
// compile with: /clr
#include <cliext/hash_set>
typedef cliext::hash_multiset<wchar_t> Myhash_multiset;
int main()
{
Myhash_multiset c1;
c1.insert(Myhash_multiset::make_value(L'a'));
c1.insert(Myhash_multiset::make_value(L'b'));
c1.insert(Myhash_multiset::make_value(L'c'));
// display contents " a b c"
for each (Myhash_multiset::value_type elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
return (0);
}
a b c
Obtient ou définit le nombre maximal d’éléments par compartiment.
float max_load_factor();
void max_load_factor(float new_factor);
new_factor
Nouveau facteur de charge maximal à stocker.
La première fonction membre retourne le facteur de charge maximal stocké actuel. Vous l’utilisez pour déterminer la taille moyenne maximale du compartiment.
La deuxième fonction membre remplace le facteur de charge maximal du magasin par new_factor
. Aucun réachage automatique n’a lieu tant qu’une insertion ultérieure n’a pas lieu.
// cliext_hash_multiset_max_load_factor.cpp
// compile with: /clr
#include <cliext/hash_set>
typedef cliext::hash_multiset<wchar_t> Myhash_multiset;
int main()
{
Myhash_multiset c1;
c1.insert(L'a');
c1.insert(L'b');
c1.insert(L'c');
// display initial contents " a b c"
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// inspect current parameters
System::Console::WriteLine("bucket_count() = {0}", c1.bucket_count());
System::Console::WriteLine("load_factor() = {0}", c1.load_factor());
System::Console::WriteLine("max_load_factor() = {0}",
c1.max_load_factor());
System::Console::WriteLine();
// change max_load_factor and redisplay
c1.max_load_factor(0.25f);
System::Console::WriteLine("bucket_count() = {0}", c1.bucket_count());
System::Console::WriteLine("load_factor() = {0}", c1.load_factor());
System::Console::WriteLine("max_load_factor() = {0}",
c1.max_load_factor());
System::Console::WriteLine();
// rehash and redisplay
c1.rehash(100);
System::Console::WriteLine("bucket_count() = {0}", c1.bucket_count());
System::Console::WriteLine("load_factor() = {0}", c1.load_factor());
System::Console::WriteLine("max_load_factor() = {0}",
c1.max_load_factor());
return (0);
}
a b c
bucket_count() = 16
load_factor() = 0.1875
max_load_factor() = 4
bucket_count() = 16
load_factor() = 0.1875
max_load_factor() = 0.25
bucket_count() = 128
load_factor() = 0.0234375
max_load_factor() = 0.25
Remplace la séquence contrôlée.
hash_multiset<Key>% operator=(hash_multiset<Key>% right);
right
Conteneur à copier.
L’opérateur membre copie right
dans l’objet, puis retourne *this
. Vous l’utilisez pour remplacer la séquence contrôlée par une copie de la séquence contrôlée dans right
.
// cliext_hash_multiset_operator_as.cpp
// compile with: /clr
#include <cliext/hash_set>
typedef cliext::hash_multiset<wchar_t> Myhash_multiset;
int main()
{
Myhash_multiset c1;
c1.insert(L'a');
c1.insert(L'b');
c1.insert(L'c');
// display contents " a b c"
for each (Myhash_multiset::value_type elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// assign to a new container
Myhash_multiset c2;
c2 = c1;
// display contents " a b c"
for each (Myhash_multiset::value_type elem in c2)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
return (0);
}
a b c
a b c
Désigne le début de la séquence contrôlée inverse.
reverse_iterator rbegin();
La fonction membre retourne un itérateur inverse qui désigne le dernier élément de la séquence contrôlée, ou juste au-delà du début d’une séquence vide. Par conséquent, il désigne la beginning
séquence inverse. Vous l’utilisez pour obtenir un itérateur qui désigne le current
début de la séquence contrôlée vue dans l’ordre inverse, mais son état peut changer si la longueur de la séquence contrôlée change.
// cliext_hash_multiset_rbegin.cpp
// compile with: /clr
#include <cliext/hash_set>
typedef cliext::hash_multiset<wchar_t> Myhash_multiset;
int main()
{
Myhash_multiset c1;
c1.insert(L'a');
c1.insert(L'b');
c1.insert(L'c');
// display initial contents " a b c"
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// inspect first two items in reversed sequence
Myhash_multiset::reverse_iterator rit = c1.rbegin();
System::Console::WriteLine("*rbegin() = {0}", *rit);
System::Console::WriteLine("*++rbegin() = {0}", *++rit);
return (0);
}
a b c
*rbegin() = c
*++rbegin() = b
Type d'une référence à un élément.
typedef value_type% reference;
Le type décrit une référence à un élément.
// cliext_hash_multiset_reference.cpp
// compile with: /clr
#include <cliext/hash_set>
typedef cliext::hash_multiset<wchar_t> Myhash_multiset;
int main()
{
Myhash_multiset c1;
c1.insert(L'a');
c1.insert(L'b');
c1.insert(L'c');
// display initial contents " a b c"
Myhash_multiset::iterator it = c1.begin();
for (; it != c1.end(); ++it)
{ // get a reference to an element
Myhash_multiset::reference ref = *it;
System::Console::Write("{0} ", ref);
}
System::Console::WriteLine();
return (0);
}
a b c
Régénère la table de hachage.
void rehash();
La fonction membre reconstruit la table de hachage, en veillant à ce que load_factor() <= max_load_factor()
. Sinon, la table de hachage augmente uniquement si nécessaire après une insertion. (Il ne diminue jamais automatiquement la taille.) Vous l’utilisez pour ajuster la taille de la table de hachage.
// cliext_hash_multiset_rehash.cpp
// compile with: /clr
#include <cliext/hash_set>
typedef cliext::hash_multiset<wchar_t> Myhash_multiset;
int main()
{
Myhash_multiset c1;
c1.insert(L'a');
c1.insert(L'b');
c1.insert(L'c');
// display initial contents " a b c"
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// inspect current parameters
System::Console::WriteLine("bucket_count() = {0}", c1.bucket_count());
System::Console::WriteLine("load_factor() = {0}", c1.load_factor());
System::Console::WriteLine("max_load_factor() = {0}",
c1.max_load_factor());
System::Console::WriteLine();
// change max_load_factor and redisplay
c1.max_load_factor(0.25f);
System::Console::WriteLine("bucket_count() = {0}", c1.bucket_count());
System::Console::WriteLine("load_factor() = {0}", c1.load_factor());
System::Console::WriteLine("max_load_factor() = {0}",
c1.max_load_factor());
System::Console::WriteLine();
// rehash and redisplay
c1.rehash(100);
System::Console::WriteLine("bucket_count() = {0}", c1.bucket_count());
System::Console::WriteLine("load_factor() = {0}", c1.load_factor());
System::Console::WriteLine("max_load_factor() = {0}",
c1.max_load_factor());
return (0);
}
a b c
bucket_count() = 16
load_factor() = 0.1875
max_load_factor() = 4
bucket_count() = 16
load_factor() = 0.1875
max_load_factor() = 0.25
bucket_count() = 128
load_factor() = 0.0234375
max_load_factor() = 0.25
Désigne la fin de la séquence contrôlée inverse.
reverse_iterator rend();
La fonction membre retourne un itérateur inverse qui pointe juste au-delà du début de la séquence contrôlée. Par conséquent, il désigne la end
séquence inverse. Vous l’utilisez pour obtenir un itérateur qui désigne la current
fin de la séquence contrôlée vue dans l’ordre inverse, mais son état peut changer si la longueur de la séquence contrôlée change.
// cliext_hash_multiset_rend.cpp
// compile with: /clr
#include <cliext/hash_set>
typedef cliext::hash_multiset<wchar_t> Myhash_multiset;
int main()
{
Myhash_multiset c1;
c1.insert(L'a');
c1.insert(L'b');
c1.insert(L'c');
// display initial contents " a b c"
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// inspect first two items
Myhash_multiset::reverse_iterator rit = c1.rend();
--rit;
System::Console::WriteLine("*-- --rend() = {0}", *--rit);
System::Console::WriteLine("*--rend() = {0}", *++rit);
return (0);
}
a b c
*-- --rend() = b
*--rend() = a
Type d'un itérateur inverse pour la séquence contrôlée.
typedef T3 reverse_iterator;
Le type décrit un objet de type T3
non spécifié qui peut servir d’itérateur inverse pour la séquence contrôlée.
// cliext_hash_multiset_reverse_iterator.cpp
// compile with: /clr
#include <cliext/hash_set>
typedef cliext::hash_multiset<wchar_t> Myhash_multiset;
int main()
{
Myhash_multiset c1;
c1.insert(L'a');
c1.insert(L'b');
c1.insert(L'c');
// display contents " a b c" reversed
Myhash_multiset::reverse_iterator rit = c1.rbegin();
for (; rit != c1.rend(); ++rit)
System::Console::Write("{0} ", *rit);
System::Console::WriteLine();
return (0);
}
c b a
Compte le nombre d'éléments.
size_type size();
La fonction membre retourne la longueur de la séquence contrôlée. Vous l’utilisez pour déterminer le nombre d’éléments actuellement dans la séquence contrôlée. Si tout ce dont vous vous souciez est de savoir si la séquence a une taille différente de zéro, voir hash_multiset::empty
.
// cliext_hash_multiset_size.cpp
// compile with: /clr
#include <cliext/hash_set>
typedef cliext::hash_multiset<wchar_t> Myhash_multiset;
int main()
{
Myhash_multiset c1;
c1.insert(L'a');
c1.insert(L'b');
c1.insert(L'c');
// display initial contents " a b c"
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
System::Console::WriteLine("size() = {0} starting with 3", c1.size());
// clear the container and reinspect
c1.clear();
System::Console::WriteLine("size() = {0} after clearing", c1.size());
// add elements and clear again
c1.insert(L'a');
c1.insert(L'b');
System::Console::WriteLine("size() = {0} after adding 2", c1.size());
return (0);
}
a b c
size() = 3 starting with 3
size() = 0 after clearing
size() = 2 after adding 2
Type d'une distance signée entre deux éléments.
typedef int size_type;
Le type décrit un nombre d’éléments non négatifs.
// cliext_hash_multiset_size_type.cpp
// compile with: /clr
#include <cliext/hash_set>
typedef cliext::hash_multiset<wchar_t> Myhash_multiset;
int main()
{
Myhash_multiset c1;
c1.insert(L'a');
c1.insert(L'b');
c1.insert(L'c');
// display initial contents " a b c"
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// compute positive difference
Myhash_multiset::size_type diff = 0;
for (Myhash_multiset::iterator it = c1.begin(); it != c1.end(); ++it)
++diff;
System::Console::WriteLine("end()-begin() = {0}", diff);
return (0);
}
a b c
end()-begin() = 3
Échange le contenu de deux conteneurs.
void swap(hash_multiset<Key>% right);
right
Conteneur avec lequel échanger le contenu.
La fonction membre échange les séquences contrôlées entre this
et right
. Il le fait en temps constant et ne lève aucune exception. Vous l’utilisez comme moyen rapide d’échanger le contenu de deux conteneurs.
// cliext_hash_multiset_swap.cpp
// compile with: /clr
#include <cliext/hash_set>
typedef cliext::hash_multiset<wchar_t> Myhash_multiset;
int main()
{
Myhash_multiset c1;
c1.insert(L'a');
c1.insert(L'b');
c1.insert(L'c');
// display initial contents " a b c"
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// construct another container with repetition of values
Myhash_multiset c2;
c2.insert(L'd');
c2.insert(L'e');
c2.insert(L'f');
for each (wchar_t elem in c2)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// swap and redisplay
c1.swap(c2);
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
for each (wchar_t elem in c2)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
return (0);
}
a b c
d e f
d e f
a b c
Copie la séquence contrôlée dans un nouveau tableau.
cli::array<value_type>^ to_array();
La fonction membre retourne un tableau contenant la séquence contrôlée. Vous l’utilisez pour obtenir une copie de la séquence contrôlée sous forme de tableau.
// cliext_hash_multiset_to_array.cpp
// compile with: /clr
#include <cliext/hash_set>
typedef cliext::hash_multiset<wchar_t> Myhash_multiset;
int main()
{
Myhash_multiset c1;
c1.insert(L'a');
c1.insert(L'b');
c1.insert(L'c');
// copy the container and modify it
cli::array<wchar_t>^ a1 = c1.to_array();
c1.insert(L'd');
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// display the earlier array copy
for each (wchar_t elem in a1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
return (0);
}
a b c d
a b c
Recherche la fin de la plage qui correspond à une clé spécifiée.
iterator upper_bound(key_type key);
key
Valeur de clé à rechercher.
La fonction membre détermine le dernier élément X
de la séquence contrôlée qui hachage dans le même compartiment que key
et a un ordre équivalent à key
. S’il n’existe aucun élément de ce type ou s’il X
s’agit du dernier élément de la séquence contrôlée, il retourne end()
; sinon, il retourne un itérateur qui désigne le premier élément au-delà X
de . Vous l’utilisez pour localiser la fin d’une séquence d’éléments actuellement dans la séquence contrôlée qui correspond à une clé spécifiée.
// cliext_hash_multiset_upper_bound.cpp
// compile with: /clr
#include <cliext/hash_set>
typedef cliext::hash_multiset<wchar_t> Myhash_multiset;
int main()
{
Myhash_multiset c1;
c1.insert(L'a');
c1.insert(L'b');
c1.insert(L'c');
// display initial contents " a b c"
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
System::Console::WriteLine("upper_bound(L'x')==end() = {0}",
c1.upper_bound(L'x') == c1.end());
System::Console::WriteLine("*upper_bound(L'a') = {0}",
*c1.upper_bound(L'a'));
System::Console::WriteLine("*upper_bound(L'b') = {0}",
*c1.upper_bound(L'b'));
return (0);
}
a b c
upper_bound(L'x')==end() = True
*upper_bound(L'a') = b
*upper_bound(L'b') = c
Copie le délégué de classement pour deux valeurs d’élément.
value_compare^ value_comp();
La fonction membre retourne le délégué de classement utilisé pour commander la séquence contrôlée. Vous l’utilisez pour comparer deux valeurs d’élément.
// cliext_hash_multiset_value_comp.cpp
// compile with: /clr
#include <cliext/hash_set>
typedef cliext::hash_multiset<wchar_t> Myhash_multiset;
int main()
{
Myhash_multiset c1;
Myhash_multiset::value_compare^ kcomp = c1.value_comp();
System::Console::WriteLine("compare(L'a', L'a') = {0}",
kcomp(L'a', L'a'));
System::Console::WriteLine("compare(L'a', L'b') = {0}",
kcomp(L'a', L'b'));
System::Console::WriteLine("compare(L'b', L'a') = {0}",
kcomp(L'b', L'a'));
System::Console::WriteLine();
return (0);
}
compare(L'a', L'a') = True
compare(L'a', L'b') = True
compare(L'b', L'a') = False
Délégué de classement pour deux valeurs d’élément.
Microsoft::VisualC::StlClr::BinaryDelegate<generic_value, generic_value, bool>
value_compare;
Le type est un synonyme du délégué qui détermine l’ordre de ses arguments de valeur.
// cliext_hash_multiset_value_compare.cpp
// compile with: /clr
#include <cliext/hash_set>
typedef cliext::hash_multiset<wchar_t> Myhash_multiset;
int main()
{
Myhash_multiset c1;
Myhash_multiset::value_compare^ kcomp = c1.value_comp();
System::Console::WriteLine("compare(L'a', L'a') = {0}",
kcomp(L'a', L'a'));
System::Console::WriteLine("compare(L'a', L'b') = {0}",
kcomp(L'a', L'b'));
System::Console::WriteLine("compare(L'b', L'a') = {0}",
kcomp(L'b', L'a'));
System::Console::WriteLine();
return (0);
}
compare(L'a', L'a') = True
compare(L'a', L'b') = True
compare(L'b', L'a') = False
Type d’un élément.
typedef generic_value value_type;
Le type est un synonyme de generic_value
.
// cliext_hash_multiset_value_type.cpp
// compile with: /clr
#include <cliext/hash_set>
typedef cliext::hash_multiset<wchar_t> Myhash_multiset;
int main()
{
Myhash_multiset c1;
c1.insert(L'a');
c1.insert(L'b');
c1.insert(L'c');
// display contents " a b c" using value_type
for (Myhash_multiset::iterator it = c1.begin(); it != c1.end(); ++it)
{ // store element in value_type object
Myhash_multiset::value_type val = *it;
System::Console::Write("{0} ", val);
}
System::Console::WriteLine();
return (0);
}
a b c