hash_set
(STL/CLR)
The template class describes an object that controls a varying-length sequence of elements that has bidirectional access. You use the container hash_set
to manage a sequence of elements as a hash table, each table entry storing a bidirectional linked list of nodes, and each node storing one element. The value of each element is used as a key, for ordering the sequence.
In the description below, GValue
is the same as GKey
, which in turn is the same as Key
unless the latter is a ref type, in which case it's Key^
.
template<typename Key>
ref class hash_set
: 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
The type of the key component of an element in the controlled sequence.
Header: <cliext/hash_set>
Namespace: cliext
Type definition | Description |
---|---|
hash_set::const_iterator |
The type of a constant iterator for the controlled sequence. |
hash_set::const_reference |
The type of a constant reference to an element. |
hash_set::const_reverse_iterator |
The type of a constant reverse iterator for the controlled sequence. |
hash_set::difference_type |
The type of a (possibly signed) distance between two elements. |
hash_set::generic_container |
The type of the generic interface for the container. |
hash_set::generic_iterator |
The type of an iterator for the generic interface for the container. |
hash_set::generic_reverse_iterator |
The type of a reverse iterator for the generic interface for the container. |
hash_set::generic_value |
The type of an element for the generic interface for the container. |
hash_set::hasher |
The hashing delegate for a key. |
hash_set::iterator |
The type of an iterator for the controlled sequence. |
hash_set::key_compare |
The ordering delegate for two keys. |
hash_set::key_type |
The type of an ordering key. |
hash_set::reference |
The type of a reference to an element. |
hash_set::reverse_iterator |
The type of a reverse iterator for the controlled sequence. |
hash_set::size_type |
The type of a (non-negative) distance between two elements. |
hash_set::value_compare |
The ordering delegate for two element values. |
hash_set::value_type |
The type of an element. |
Member function | Description |
---|---|
hash_set::begin |
Designates the beginning of the controlled sequence. |
hash_set::bucket_count |
Counts the number of buckets. |
hash_set::clear |
Removes all elements. |
hash_set::count |
Counts elements matching a specified key. |
hash_set::empty |
Tests whether no elements are present. |
hash_set::end |
Designates the end of the controlled sequence. |
hash_set::equal_range |
Finds range that matches a specified key. |
hash_set::erase |
Removes elements at specified positions. |
hash_set::find |
Finds an element that matches a specified key. |
hash_set::hash_delegate |
Copies the hashing delegate for a key. |
hash_set::hash_set |
Constructs a container object. |
hash_set::insert |
Adds elements. |
hash_set::key_comp |
Copies the ordering delegate for two keys. |
hash_set::load_factor |
Counts the average elements per bucket. |
hash_set::lower_bound |
Finds beginning of range that matches a specified key. |
hash_set::make_value |
Constructs a value object. |
hash_set::max_load_factor |
Gets or sets the maximum elements per bucket. |
hash_set::rbegin |
Designates the beginning of the reversed controlled sequence. |
hash_set::rehash |
Rebuilds the hash table. |
hash_set::rend |
Designates the end of the reversed controlled sequence. |
hash_set::size |
Counts the number of elements. |
hash_set::swap |
Swaps the contents of two containers. |
hash_set::to_array |
Copies the controlled sequence to a new array. |
hash_set::upper_bound |
Finds end of range that matches a specified key. |
hash_set::value_comp |
Copies the ordering delegate for two element values. |
Operator | Description |
---|---|
hash_set::operator= |
Replaces the controlled sequence. |
Interface | Description |
---|---|
ICloneable | Duplicate an object. |
IEnumerable | Sequence through elements. |
ICollection | Maintain group of elements. |
IEnumerable<T> | Sequence through typed elements. |
ICollection<T> | Maintain group of typed elements. |
IHash<Key, Value> |
Maintain generic container. |
The object allocates and frees storage for the sequence it controls as individual nodes in a bidirectional linked list. To speed access, the object also maintains a varying-length array of pointers into the list (the hash table), effectively managing the whole list as a sequence of sublists, or buckets. It inserts elements into a bucket that it keeps ordered by altering the links between nodes, never by copying the contents of one node to another. That means you can insert and remove elements freely without disturbing remaining elements.
The object orders each bucket it controls by calling a stored delegate object of type hash_set::key_compare
. You can specify the stored delegate object when you construct the hash_set; if you specify no delegate object, the default is the comparison operator<=(key_type, key_type)
.
You access the stored delegate object by calling the member function hash_set::key_comp
. Such a delegate object must define equivalent ordering between keys of type hash_set::key_type
. That means, for any two keys X
and Y
:
key_comp()(X, Y)
returns the same Boolean result on every call.
If key_comp()(X, Y) && key_comp()(Y, X)
is true, then X
and Y
are said to have equivalent ordering.
Any ordering rule that behaves like operator<=(key_type, key_type)
, operator>=(key_type, key_type)
or operator==(key_type, key_type)
defines equivalent ordering.
The container ensures only that elements whose keys have equivalent ordering (and which hash to the same integer value) are adjacent within a bucket. Unlike template class hash_multiset (STL/CLR), an object of template class hash_set
ensures that keys for all elements are unique. (No two keys have equivalent ordering.)
The object determines which bucket should contain a given ordering key by calling a stored delegate object of type hash_set::hasher
. You access this stored object by calling the member function hash_set::hash_delegate
to obtain an integer value that depends on the key value. You can specify the stored delegate object when you construct the hash_set; if you specify no delegate object, the default is the function System::Object::hash_value(key_type)
. That means, for any keys X
and Y
:
hash_delegate()(X)
returns the same integer result on every call.
If X
and Y
have equivalent ordering, then hash_delegate()(X)
should return the same integer result as hash_delegate()(Y)
.
Each element serves as both a key and a value. The sequence is represented in a way that permits lookup, insertion, and removal of an arbitrary element in constant time. That is, the number of operations is independent of the number of elements in the sequence, at least in the best of cases. Moreover, inserting an element invalidates no iterators, and removing an element invalidates only those iterators that point at the removed element.
If hashed values aren't uniformly distributed, however, a hash table can degenerate. In the extreme (for a hash function that always returns the same value), lookup, insertion, and removal are proportional to the number of elements in the sequence (linear time). The container endeavors to choose a reasonable hash function, mean bucket size, and hash-table size (total number of buckets), but you can override any or all of these choices. See, for example, the functions hash_set::max_load_factor
and hash_set::rehash
.
A hash_set
supports bidirectional iterators, which means you can step to adjacent elements given an iterator that designates an element in the controlled sequence. A special head node corresponds to the iterator returned by end()
. You can decrement this iterator to reach the last element in the controlled sequence, if present. You can increment a hash_set
iterator to reach the head node, and it will then compare equal to end()
. But you can't dereference the iterator returned by end()
.
You can't refer to a hash_set
element directly given its numerical position. That requires a random-access iterator.
A hash_set
iterator stores a handle to its associated hash_set
node, which in turn stores a handle to its associated container. You can use iterators only with their associated container objects. A hash_set
iterator remains valid so long as its associated hash_set
node is associated with some hash_set. Moreover, a valid iterator is dereferencable. You can use it to access or alter the element value it designates, so long as it isn't equal to end()
.
Erasing or removing an element calls the destructor for its stored value. Destroying the container erases all elements. Thus, a container whose element type is a ref class ensures that no elements outlive the container. However, a container of handles doesn't destroy its elements.
Designates the beginning of the controlled sequence.
iterator begin();
The member function returns a bidirectional iterator that designates the first element of the controlled sequence, or just beyond the end of an empty sequence. You use it to obtain an iterator that designates the current
beginning of the controlled sequence, but its status can change if the length of the controlled sequence changes.
// cliext_hash_set_begin.cpp
// compile with: /clr
#include <cliext/hash_set>
typedef cliext::hash_set<wchar_t> Myhash_set;
int main()
{
Myhash_set 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_set::iterator it = c1.begin();
System::Console::WriteLine("*begin() = {0}", *it);
System::Console::WriteLine("*++begin() = {0}", *++it);
return (0);
}
Counts the number of buckets.
int bucket_count();
The member function returns the current number of buckets. You use it to determine the size of the hash table.
// cliext_hash_set_bucket_count.cpp
// compile with: /clr
#include <cliext/hash_set>
typedef cliext::hash_set<wchar_t> Myhash_set;
int main()
{
Myhash_set 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
Removes all elements.
void clear();
The member function effectively calls erase(begin(), end())
. You use it to ensure that the controlled sequence is empty.
// cliext_hash_set_clear.cpp
// compile with: /clr
#include <cliext/hash_set>
typedef cliext::hash_set<wchar_t> Myhash_set;
int main()
{
Myhash_set 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
The type of a constant iterator for the controlled sequence.
typedef T2 const_iterator;
The type describes an object of unspecified type T2
that can serve as a constant bidirectional iterator for the controlled sequence.
// cliext_hash_set_const_iterator.cpp
// compile with: /clr
#include <cliext/hash_set>
typedef cliext::hash_set<wchar_t> Myhash_set;
int main()
{
Myhash_set c1;
c1.insert(L'a');
c1.insert(L'b');
c1.insert(L'c');
// display contents " a b c"
Myhash_set::const_iterator cit = c1.begin();
for (; cit != c1.end(); ++cit)
System::Console::Write("{0} ", *cit);
System::Console::WriteLine();
return (0);
}
a b c
The type of a constant reference to an element.
typedef value_type% const_reference;
The type describes a constant reference to an element.
// cliext_hash_set_const_reference.cpp
// compile with: /clr
#include <cliext/hash_set>
typedef cliext::hash_set<wchar_t> Myhash_set;
int main()
{
Myhash_set c1;
c1.insert(L'a');
c1.insert(L'b');
c1.insert(L'c');
// display initial contents " a b c"
Myhash_set::const_iterator cit = c1.begin();
for (; cit != c1.end(); ++cit)
{ // get a const reference to an element
Myhash_set::const_reference cref = *cit;
System::Console::Write("{0} ", cref);
}
System::Console::WriteLine();
return (0);
}
a b c
The type of a constant reverse iterator for the controlled sequence.
typedef T4 const_reverse_iterator;
The type describes an object of unspecified type T4
that can serve as a constant reverse iterator for the controlled sequence.
// cliext_hash_set_const_reverse_iterator.cpp
// compile with: /clr
#include <cliext/hash_set>
typedef cliext::hash_set<wchar_t> Myhash_set;
int main()
{
Myhash_set c1;
c1.insert(L'a');
c1.insert(L'b');
c1.insert(L'c');
// display contents " a b c" reversed
Myhash_set::const_reverse_iterator crit = c1.rbegin();
for (; crit != c1.rend(); ++crit)
System::Console::Write("{0} ", *crit);
System::Console::WriteLine();
return (0);
}
c b a
Finds the number of elements matching a specified key.
size_type count(key_type key);
key
Key value to search for.
The member function returns the number of elements in the controlled sequence that have equivalent ordering with key
. You use it to determine the number of elements currently in the controlled sequence that match a specified key.
// cliext_hash_set_count.cpp
// compile with: /clr
#include <cliext/hash_set>
typedef cliext::hash_set<wchar_t> Myhash_set;
int main()
{
Myhash_set 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
The types of a signed distance between two elements.
typedef int difference_type;
The type describes a possibly negative element count.
// cliext_hash_set_difference_type.cpp
// compile with: /clr
#include <cliext/hash_set>
typedef cliext::hash_set<wchar_t> Myhash_set;
int main()
{
Myhash_set 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_set::difference_type diff = 0;
for (Myhash_set::iterator it = c1.begin(); it != c1.end(); ++it)
++diff;
System::Console::WriteLine("end()-begin() = {0}", diff);
// compute negative difference
diff = 0;
for (Myhash_set::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
Tests whether no elements are present.
bool empty();
The member function returns true for an empty controlled sequence. It's equivalent to size() == 0
. You use it to test whether the hash_set
is empty.
// cliext_hash_set_empty.cpp
// compile with: /clr
#include <cliext/hash_set>
typedef cliext::hash_set<wchar_t> Myhash_set;
int main()
{
Myhash_set 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
Designates the end of the controlled sequence.
iterator end();
The member function returns a bidirectional iterator that points just beyond the end of the controlled sequence. You use it to obtain an iterator that designates the end of the controlled sequence; its status doesn't change if the length of the controlled sequence changes.
// cliext_hash_set_end.cpp
// compile with: /clr
#include <cliext/hash_set>
typedef cliext::hash_set<wchar_t> Myhash_set;
int main()
{
Myhash_set 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_set::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
Finds range that matches a specified key.
cliext::pair<iterator, iterator> equal_range(key_type key);
key
Key value to search for.
The member function returns a pair of iterators cliext::pair<iterator, iterator>(lower_bound(key), upper_bound(key))
. You use it to determine the range of elements currently in the controlled sequence that match a specified key.
// cliext_hash_set_equal_range.cpp
// compile with: /clr
#include <cliext/hash_set>
typedef cliext::hash_set<wchar_t> Myhash_set;
typedef Myhash_set::pair_iter_iter Pairii;
int main()
{
Myhash_set 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
Removes elements at specified positions.
iterator erase(iterator where);
iterator erase(iterator first, iterator last);
bool erase(key_type key)
first
Beginning of range to erase.
key
Key value to erase.
last
End of range to erase.
where
Element to erase.
The first member function removes the element of the controlled sequence pointed to by where
, and returns an iterator that designates the first element remaining beyond the element removed, or end()
if no such element exists. You use it to remove a single element.
The second member function removes the elements of the controlled sequence in the range [first
, last
), and returns an iterator that designates the first element remaining beyond any elements removed, or end()
if no such element exists. You use it to remove zero or more contiguous elements.
The third member function removes any element of the controlled sequence whose key has equivalent ordering to key
, and returns a count of the number of elements removed. You use it to remove and count all elements that match a specified key.
Each element erasure takes time proportional to the logarithm of the number of elements in the controlled sequence.
// cliext_hash_set_erase.cpp
// compile with: /clr
#include <cliext/hash_set>
typedef cliext::hash_set<wchar_t> Myhash_set;
int main()
{
Myhash_set 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_set::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
Finds an element that matches a specified key.
iterator find(key_type key);
key
Key value to search for.
If at least one element in the controlled sequence has equivalent ordering with key
, the member function returns an iterator designating one of those elements; otherwise it returns end()
. You use it to locate an element currently in the controlled sequence that matches a specified key.
// cliext_hash_set_find.cpp
// compile with: /clr
#include <cliext/hash_set>
typedef cliext::hash_set<wchar_t> Myhash_set;
int main()
{
Myhash_set 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
The type of the generic interface for the container.
typedef Microsoft::VisualC::StlClr::
IHash<GKey, GValue>
generic_container;
The type describes the generic interface for this template container class.
// cliext_hash_set_generic_container.cpp
// compile with: /clr
#include <cliext/hash_set>
typedef cliext::hash_set<wchar_t> Myhash_set;
int main()
{
Myhash_set 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_set::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
The type of an iterator for use with the generic interface for the container.
typedef Microsoft::VisualC::StlClr::Generic::
ContainerBidirectionalIterator<generic_value>
generic_iterator;
The type describes a generic iterator that can be used with the generic interface for this template container class.
// cliext_hash_set_generic_iterator.cpp
// compile with: /clr
#include <cliext/hash_set>
typedef cliext::hash_set<wchar_t> Myhash_set;
int main()
{
Myhash_set 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_set::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_set::generic_iterator gcit = gc1->begin();
Myhash_set::generic_value gcval = *gcit;
System::Console::WriteLine("{0} ", gcval);
return (0);
}
a b c
a b c
a
The type of a reverse iterator for use with the generic interface for the container.
typedef Microsoft::VisualC::StlClr::Generic::
ReverseRandomAccessIterator<generic_value>
generic_reverse_iterator;
The type describes a generic reverse iterator that can be used with the generic interface for this template container class.
// cliext_hash_set_generic_reverse_iterator.cpp
// compile with: /clr
#include <cliext/hash_set>
typedef cliext::hash_set<wchar_t> Myhash_set;
int main()
{
Myhash_set 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_set::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_set::generic_reverse_iterator gcit = gc1->rbegin();
Myhash_set::generic_value gcval = *gcit;
System::Console::WriteLine("{0} ", gcval);
return (0);
}
a b c
a b c
c
The type of an element for use with the generic interface for the container.
typedef GValue generic_value;
The type describes an object of type GValue
that describes the stored element value for use with the generic interface for this template container class.
// cliext_hash_set_generic_value.cpp
// compile with: /clr
#include <cliext/hash_set>
typedef cliext::hash_set<wchar_t> Myhash_set;
int main()
{
Myhash_set 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_set::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_set::generic_iterator gcit = gc1->begin();
Myhash_set::generic_value gcval = *gcit;
System::Console::WriteLine("{0} ", gcval);
return (0);
}
a b c
a b c
a
Finds an element that matches a specified key.
hasher^ hash_delegate();
The member function returns the delegate used to convert a key value to an integer. You use it to hash a key.
// cliext_hash_set_hash_delegate.cpp
// compile with: /clr
#include <cliext/hash_set>
typedef cliext::hash_set<wchar_t> Myhash_set;
int main()
{
Myhash_set c1;
Myhash_set::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
Constructs a container object.
hash_set();
explicit hash_set(key_compare^ pred);
hash_set(key_compare^ pred, hasher^ hashfn);
hash_set(hash_set<Key>% right);
hash_set(hash_set<Key>^ right);
template<typename InIter>
hash_sethash_set(InIter first, InIter last);
template<typename InIter>
hash_set(InIter first, InIter last,
key_compare^ pred);
template<typename InIter>
hash_set(InIter first, InIter last,
key_compare^ pred, hasher^ hashfn);
hash_set(System::Collections::Generic::IEnumerable<GValue>^ right);
hash_set(System::Collections::Generic::IEnumerable<GValue>^ right,
key_compare^ pred);
hash_set(System::Collections::Generic::IEnumerable<GValue>^ right,
key_compare^ pred, hasher^ hashfn);
first
Beginning of range to insert.
hashfn
Hash function for mapping keys to buckets.
last
End of range to insert.
pred
Ordering predicate for the controlled sequence.
right
Object or range to insert.
The constructor:
hash_set();
initializes the controlled sequence with no elements, with the default ordering predicate key_compare()
, and with the default hash function. You use it to specify an empty initial controlled sequence, with the default ordering predicate and hash function.
The constructor:
explicit hash_set(key_compare^ pred);
initializes the controlled sequence with no elements, with the ordering predicate pred
, and with the default hash function. You use it to specify an empty initial controlled sequence, with the specified ordering predicate and the default hash function.
The constructor:
hash_set(key_compare^ pred, hasher^ hashfn);
initializes the controlled sequence with no elements, with the ordering predicate pred
, and with the hash function hashfn
. You use it to specify an empty initial controlled sequence, with the specified ordering predicate and hash function.
The constructor:
hash_set(hash_set<Key>% right);
initializes the controlled sequence with the sequence [right.begin()
, right.end()
), with the default ordering predicate, and with the default hash function. You use it to specify an initial controlled sequence that is a copy of the sequence controlled by the hash_set
object right
, with the default ordering predicate and hash function.
The constructor:
hash_set(hash_set<Key>^ right);
initializes the controlled sequence with the sequence [right->begin()
, right->end()
), with the default ordering predicate, and with the default hash function. You use it to specify an initial controlled sequence that is a copy of the sequence controlled by the hash_set
object right
, with the default ordering predicate and hash function.
The constructor:
template<typename InIter> hash_set(InIter first, InIter last);
initializes the controlled sequence with the sequence [first
, last
), with the default ordering predicate, and with the default hash function. You use it to make the controlled sequence a copy of another sequence, with the default ordering predicate and hash function.
The constructor:
template<typename InIter> hash_set(InIter first, InIter last, key_compare^ pred);
initializes the controlled sequence with the sequence [first
, last
), with the ordering predicate pred
, and with the default hash function. You use it to make the controlled sequence a copy of another sequence, with the specified ordering predicate and the default hash function.
The constructor:
template<typename InIter> hash_set(InIter first, InIter last, key_compare^ pred, hasher^ hashfn);
initializes the controlled sequence with the sequence [first
, last
), with the ordering predicate pred
, and with the hash function hashfn
. You use it to make the controlled sequence a copy of another sequence, with the specified ordering predicate and hash function.
The constructor:
hash_set(System::Collections::Generic::IEnumerable<Key>^ right);
initializes the controlled sequence with the sequence designated by the enumerator right
, with the default ordering predicate, and with the default hash function. You use it to make the controlled sequence a copy of another sequence described by an enumerator, with the default ordering predicate and hash function.
The constructor:
hash_set(System::Collections::Generic::IEnumerable<Key>^ right, key_compare^ pred);
initializes the controlled sequence with the sequence designated by the enumerator right
, with the ordering predicate pred
, and with the default hash function. You use it to make the controlled sequence a copy of another sequence described by an enumerator, with the specified ordering predicate and default hash function.
The constructor:
hash_set(System::Collections::Generic::IEnumerable<Key>^ right, key_compare^ pred, hasher^ hashfn);
initializes the controlled sequence with the sequence designated by the enumerator right
, with the ordering predicate pred
, and with the hash function hashfn
. You use it to make the controlled sequence a copy of another sequence described by an enumerator, with the specified ordering predicate and hash function.
// cliext_hash_set_construct.cpp
// compile with: /clr
#include <cliext/hash_set>
int myfun(wchar_t key)
{ // hash a key
return (key ^ 0xdeadbeef);
}
typedef cliext::hash_set<wchar_t> Myhash_set;
int main()
{
// construct an empty container
Myhash_set 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_set 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_set c2h(cliext::greater_equal<wchar_t>(),
gcnew Myhash_set::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_set 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_set 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_set c4h(c1.begin(), c1.end(),
cliext::greater_equal<wchar_t>(),
gcnew Myhash_set::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_set 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_set 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_set c6h( // NOTE: cast is not needed
(System::Collections::Generic::IEnumerable<wchar_t>^)%c3,
cliext::greater_equal<wchar_t>(),
gcnew Myhash_set::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_set c7(c4);
for each (wchar_t elem in c7)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// construct by copying another container
Myhash_set 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
The hashing delegate for a key.
Microsoft::VisualC::StlClr::UnaryDelegate<GKey, int>
hasher;
The type describes a delegate that converts a key value to an integer.
// cliext_hash_set_hasher.cpp
// compile with: /clr
#include <cliext/hash_set>
typedef cliext::hash_set<wchar_t> Myhash_set;
int main()
{
Myhash_set c1;
Myhash_set::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
Adds elements.
cliext::pair<iterator, bool> 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
Beginning of range to insert.
last
End of range to insert.
right
Enumeration to insert.
val
Key value to insert.
where
Where in container to insert (hint only).
Each of the member functions inserts a sequence specified by the remaining operands.
The first member function endeavors to insert an element with value val
, and returns a pair of values X
. If X.second
is true, X.first
designates the newly inserted element; otherwise X.first
designates an element with equivalent ordering that already exists and no new element is inserted. You use it to insert a single element.
The second member function inserts an element with value val
, using where
as a hint (to improve performance), and returns an iterator that designates the newly inserted element. You use it to insert a single element that might be next to an element you know.
The third member function inserts the sequence [first
, last
). You use it to insert zero or more elements copied from another sequence.
The fourth member function inserts the sequence designated by the right
. You use it to insert a sequence described by an enumerator.
Each element insertion takes time proportional to the logarithm of the number of elements in the controlled sequence. Insertion can occur in amortized constant time, however, given a hint that designates an element next to the insertion point.
// cliext_hash_set_insert.cpp
// compile with: /clr
#include <cliext/hash_set>
typedef cliext::hash_set<wchar_t> Myhash_set;
typedef Myhash_set::pair_iter_bool Pairib;
int main()
{
Myhash_set 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
Pairib pair1 = c1.insert(L'x');
System::Console::WriteLine("insert(L'x') = [{0} {1}]",
*pair1.first, pair1.second);
pair1 = c1.insert(L'b');
System::Console::WriteLine("insert(L'b') = [{0} {1}]",
*pair1.first, pair1.second);
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_set c2;
Myhash_set::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_set 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 True]
insert(L'b') = [b False]
a b c x
insert(begin(), L'y') = y
a b c x y
a b c x
a b c x y
The type of an iterator for the controlled sequence.
typedef T1 iterator;
The type describes an object of unspecified type T1
that can serve as a bidirectional iterator for the controlled sequence.
// cliext_hash_set_iterator.cpp
// compile with: /clr
#include <cliext/hash_set>
typedef cliext::hash_set<wchar_t> Myhash_set;
int main()
{
Myhash_set c1;
c1.insert(L'a');
c1.insert(L'b');
c1.insert(L'c');
// display contents " a b c"
Myhash_set::iterator it = c1.begin();
for (; it != c1.end(); ++it)
System::Console::Write("{0} ", *it);
System::Console::WriteLine();
return (0);
}
a b c
Copies the ordering delegate for two keys.
key_compare^key_comp();
The member function returns the ordering delegate used to order the controlled sequence. You use it to compare two keys.
// cliext_hash_set_key_comp.cpp
// compile with: /clr
#include <cliext/hash_set>
typedef cliext::hash_set<wchar_t> Myhash_set;
int main()
{
Myhash_set c1;
Myhash_set::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_set 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
The ordering delegate for two keys.
Microsoft::VisualC::StlClr::BinaryDelegate<GKey, GKey, bool>
key_compare;
The type is a synonym for the delegate that determines the ordering of its key arguments.
// cliext_hash_set_key_compare.cpp
// compile with: /clr
#include <cliext/hash_set>
typedef cliext::hash_set<wchar_t> Myhash_set;
int main()
{
Myhash_set c1;
Myhash_set::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_set 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
The type of an ordering key.
typedef Key key_type;
The type is a synonym for the template parameter Key
.
// cliext_hash_set_key_type.cpp
// compile with: /clr
#include <cliext/hash_set>
typedef cliext::hash_set<wchar_t> Myhash_set;
int main()
{
Myhash_set c1;
c1.insert(L'a');
c1.insert(L'b');
c1.insert(L'c');
// display contents " a b c" using key_type
for (Myhash_set::iterator it = c1.begin(); it != c1.end(); ++it)
{ // store element in key_type object
Myhash_set::key_type val = *it;
System::Console::Write("{0} ", val);
}
System::Console::WriteLine();
return (0);
}
a b c
Counts the average elements per bucket.
float load_factor();
The member function returns (float)size() / bucket_count()
. You use it to determine the average bucket size.
// cliext_hash_set_load_factor.cpp
// compile with: /clr
#include <cliext/hash_set>
typedef cliext::hash_set<wchar_t> Myhash_set;
int main()
{
Myhash_set 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
Finds beginning of range that matches a specified key.
iterator lower_bound(key_type key);
key
Key value to search for.
The member function determines the first element X
in the controlled sequence that hashes to the same bucket as key
and has equivalent ordering to key
. If no such element exists, it returns end()
; otherwise it returns an iterator that designates X
. You use it to locate the beginning of a sequence of elements currently in the controlled sequence that match a specified key.
// cliext_hash_set_lower_bound.cpp
// compile with: /clr
#include <cliext/hash_set>
typedef cliext::hash_set<wchar_t> Myhash_set;
int main()
{
Myhash_set 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
Constructs a value object.
static value_type make_value(key_type key);
key
Key value to use.
The member function returns a value_type
object whose key is key
. You use it to compose an object suitable for use with several other member functions.
// cliext_hash_set_make_value.cpp
// compile with: /clr
#include <cliext/hash_set>
typedef cliext::hash_set<wchar_t> Myhash_set;
int main()
{
Myhash_set c1;
c1.insert(Myhash_set::make_value(L'a'));
c1.insert(Myhash_set::make_value(L'b'));
c1.insert(Myhash_set::make_value(L'c'));
// display contents " a b c"
for each (Myhash_set::value_type elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
return (0);
}
a b c
Gets or sets the maximum elements per bucket.
float max_load_factor();
void max_load_factor(float new_factor);
new_factor
New maximum load factor to store.
The first member function returns the current stored maximum load factor. You use it to determine the maximum average bucket size.
The second member function replaces the store maximum load factor with new_factor
. No automatic rehashing occurs until a subsequent insert.
// cliext_hash_set_max_load_factor.cpp
// compile with: /clr
#include <cliext/hash_set>
typedef cliext::hash_set<wchar_t> Myhash_set;
int main()
{
Myhash_set 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);
}
Replaces the controlled sequence.
hash_set<Key>% operator=(hash_set<Key>% right);
right
Container to copy.
The member operator copies right
to the object, then returns *this
. You use it to replace the controlled sequence with a copy of the controlled sequence in right
.
// cliext_hash_set_operator_as.cpp
// compile with: /clr
#include <cliext/hash_set>
typedef cliext::hash_set<wchar_t> Myhash_set;
int main()
{
Myhash_set c1;
c1.insert(L'a');
c1.insert(L'b');
c1.insert(L'c');
// display contents " a b c"
for each (Myhash_set::value_type elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// assign to a new container
Myhash_set c2;
c2 = c1;
// display contents " a b c"
for each (Myhash_set::value_type elem in c2)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
return (0);
}
a b c
a b c
Designates the beginning of the reversed controlled sequence.
reverse_iterator rbegin();
The member function returns a reverse iterator that designates the last element of the controlled sequence, or just beyond the beginning of an empty sequence. Hence, it designates the beginning
of the reverse sequence. You use it to obtain an iterator that designates the current
beginning of the controlled sequence seen in reverse order, but its status can change if the length of the controlled sequence changes.
// cliext_hash_set_rbegin.cpp
// compile with: /clr
#include <cliext/hash_set>
typedef cliext::hash_set<wchar_t> Myhash_set;
int main()
{
Myhash_set 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_set::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
The type of a reference to an element.
typedef value_type% reference;
The type describes a reference to an element.
// cliext_hash_set_reference.cpp
// compile with: /clr
#include <cliext/hash_set>
typedef cliext::hash_set<wchar_t> Myhash_set;
int main()
{
Myhash_set c1;
c1.insert(L'a');
c1.insert(L'b');
c1.insert(L'c');
// display initial contents " a b c"
Myhash_set::iterator it = c1.begin();
for (; it != c1.end(); ++it)
{ // get a reference to an element
Myhash_set::reference ref = *it;
System::Console::Write("{0} ", ref);
}
System::Console::WriteLine();
return (0);
}
a b c
Rebuilds the hash table.
void rehash();
The member function rebuilds the hash table, ensuring that load_factor() <= max_load_factor()
. Otherwise, the hash table increases in size only as needed after an insertion. (It never automatically decreases in size.) You use it to adjust the size of the hash table.
// cliext_hash_set_rehash.cpp
// compile with: /clr
#include <cliext/hash_set>
typedef cliext::hash_set<wchar_t> Myhash_set;
int main()
{
Myhash_set 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
Designates the end of the reversed controlled sequence.
reverse_iterator rend();
The member function returns a reverse iterator that points just beyond the beginning of the controlled sequence. Hence, it designates the end
of the reverse sequence. You use it to obtain an iterator that designates the current
end of the controlled sequence seen in reverse order, but its status can change if the length of the controlled sequence changes.
// cliext_hash_set_rend.cpp
// compile with: /clr
#include <cliext/hash_set>
typedef cliext::hash_set<wchar_t> Myhash_set;
int main()
{
Myhash_set 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_set::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
The type of a reverse iterator for the controlled sequence.
typedef T3 reverse_iterator;
The type describes an object of unspecified type T3
that can serve as a reverse iterator for the controlled sequence.
// cliext_hash_set_reverse_iterator.cpp
// compile with: /clr
#include <cliext/hash_set>
typedef cliext::hash_set<wchar_t> Myhash_set;
int main()
{
Myhash_set c1;
c1.insert(L'a');
c1.insert(L'b');
c1.insert(L'c');
// display contents " a b c" reversed
Myhash_set::reverse_iterator rit = c1.rbegin();
for (; rit != c1.rend(); ++rit)
System::Console::Write("{0} ", *rit);
System::Console::WriteLine();
return (0);
}
c b a
Counts the number of elements.
size_type size();
The member function returns the length of the controlled sequence. You use it to determine the number of elements currently in the controlled sequence. If all you care about is whether the sequence has nonzero size, see empty()
.
// cliext_hash_set_size.cpp
// compile with: /clr
#include <cliext/hash_set>
typedef cliext::hash_set<wchar_t> Myhash_set;
int main()
{
Myhash_set 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
The type of a signed distance between two elements.
typedef int size_type;
The type describes a non-negative element count.
// cliext_hash_set_size_type.cpp
// compile with: /clr
#include <cliext/hash_set>
typedef cliext::hash_set<wchar_t> Myhash_set;
int main()
{
Myhash_set 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_set::size_type diff = 0;
for (Myhash_set::iterator it = c1.begin(); it != c1.end(); ++it)
++diff;
System::Console::WriteLine("end()-begin() = {0}", diff);
return (0);
}
a b c
end()-begin() = 3
Swaps the contents of two containers.
void swap(hash_set<Key>% right);
right
Container to swap contents with.
The member function swaps the controlled sequences between this
and right
. It does so in constant time and it throws no exceptions. You use it as a quick way to exchange the contents of two containers.
// cliext_hash_set_swap.cpp
// compile with: /clr
#include <cliext/hash_set>
typedef cliext::hash_set<wchar_t> Myhash_set;
int main()
{
Myhash_set 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_set 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
Copies the controlled sequence to a new array.
cli::array<value_type>^ to_array();
The member function returns an array containing the controlled sequence. You use it to obtain a copy of the controlled sequence in array form.
// cliext_hash_set_to_array.cpp
// compile with: /clr
#include <cliext/hash_set>
typedef cliext::hash_set<wchar_t> Myhash_set;
int main()
{
Myhash_set 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
Finds end of range that matches a specified key.
iterator upper_bound(key_type key);
key
Key value to search for.
The member function determines the last element X
in the controlled sequence that hashes to the same bucket as key
and has equivalent ordering to key
. If no such element exists, or if X
is the last element in the controlled sequence, it returns end()
; otherwise it returns an iterator that designates the first element beyond X
. You use it to locate the end of a sequence of elements currently in the controlled sequence that match a specified key.
// cliext_hash_set_upper_bound.cpp
// compile with: /clr
#include <cliext/hash_set>
typedef cliext::hash_set<wchar_t> Myhash_set;
int main()
{
Myhash_set 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
Copies the ordering delegate for two element values.
value_compare^ value_comp();
The member function returns the ordering delegate used to order the controlled sequence. You use it to compare two element values.
// cliext_hash_set_value_comp.cpp
// compile with: /clr
#include <cliext/hash_set>
typedef cliext::hash_set<wchar_t> Myhash_set;
int main()
{
Myhash_set c1;
Myhash_set::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
The ordering delegate for two element values.
Microsoft::VisualC::StlClr::BinaryDelegate<generic_value, generic_value, bool>
value_compare;
The type is a synonym for the delegate that determines the ordering of its value arguments.
// cliext_hash_set_value_compare.cpp
// compile with: /clr
#include <cliext/hash_set>
typedef cliext::hash_set<wchar_t> Myhash_set;
int main()
{
Myhash_set c1;
Myhash_set::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
The type of an element.
typedef generic_value value_type;
The type is a synonym for generic_value
.
// cliext_hash_set_value_type.cpp
// compile with: /clr
#include <cliext/hash_set>
typedef cliext::hash_set<wchar_t> Myhash_set;
int main()
{
Myhash_set c1;
c1.insert(L'a');
c1.insert(L'b');
c1.insert(L'c');
// display contents " a b c" using value_type
for (Myhash_set::iterator it = c1.begin(); it != c1.end(); ++it)
{ // store element in value_type object
Myhash_set::value_type val = *it;
System::Console::Write("{0} ", val);
}
System::Console::WriteLine();
return (0);
}
a b c