title | description | ms.date | f1_keywords | helpviewer_keywords | ms.assetid | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
unordered_multiset Class |
API reference for the C++ Standard Library container class `unordered_multiset`, which describes an object used for the storage and retrieval of data from a collection in which the values of the elements contained need not be unique and in which they serve as the key values. The data isn't automatically ordered. |
9/10/2020 |
|
|
70c8dfc5-492a-4af2-84f5-1aa9cb04b71c |
The class template describes an object that controls a varying-length sequence of elements of type const Key
. The sequence is weakly ordered by a hash function, which partitions the sequence into an ordered set of subsequences called buckets. Within each bucket a comparison function determines whether any pair of elements has equivalent ordering. Each element serves as both a sort key and a value. The sequence is represented in a way that permits lookup, insertion, and removal of an arbitrary element with a number of operations that can be independent of the number of elements in the sequence (constant time), at least when all buckets are of roughly equal length. In the worst case, when all of the elements are in one bucket, the number of operations is proportional to the number of elements in the sequence (linear time). Moreover, inserting an element invalidates no iterators, and removing an element invalidates only those iterators which point at the removed element.
template <class Key,
class Hash = std::hash<Key>,
class Pred = std::equal_to<Key>,
class Alloc = std::allocator<Key>>
class unordered_multiset;
Key
The key type.
Hash
The hash function object type.
Pred
The equality comparison function object type.
Alloc
The allocator class.
Type Definition | Description |
---|---|
allocator_type | The type of an allocator for managing storage. |
const_iterator | The type of a constant iterator for the controlled sequence. |
const_local_iterator | The type of a constant bucket iterator for the controlled sequence. |
const_pointer | The type of a constant pointer to an element. |
const_reference | The type of a constant reference to an element. |
difference_type | The type of a signed distance between two elements. |
hasher | The type of the hash function. |
iterator | The type of an iterator for the controlled sequence. |
key_equal | The type of the comparison function. |
key_type | The type of an ordering key. |
local_iterator | The type of a bucket iterator for the controlled sequence. |
pointer | The type of a pointer to an element. |
reference | The type of a reference to an element. |
size_type | The type of an unsigned distance between two elements. |
value_type | The type of an element. |
Member Function | Description |
---|---|
begin | Designates the beginning of the controlled sequence. |
bucket | Gets the bucket number for a key value. |
bucket_count | Gets the number of buckets. |
bucket_size | Gets the size of a bucket. |
cbegin | Designates the beginning of the controlled sequence. |
cend | Designates the end of the controlled sequence. |
clear | Removes all elements. |
containsC++20 | Checks if there's an element with the specified key. |
count | Finds the number of elements matching a specified key. |
emplace | Adds an element constructed in place. |
emplace_hint | Adds an element constructed in place, with hint. |
empty | Tests whether no elements are present. |
end | Designates the end of the controlled sequence. |
equal_range | Finds range that matches a specified key. |
erase | Removes elements at specified positions. |
find | Finds an element that matches a specified key. |
get_allocator | Gets the stored allocator object. |
hash_function | Gets the stored hash function object. |
insert | Adds elements. |
key_eq | Gets the stored comparison function object. |
load_factor | Counts the average elements per bucket. |
max_bucket_count | Gets the maximum number of buckets. |
max_load_factor | Gets or sets the maximum elements per bucket. |
max_size | Gets the maximum size of the controlled sequence. |
rehash | Rebuilds the hash table. |
size | Counts the number of elements. |
swap | Swaps the contents of two containers. |
unordered_multiset | Constructs a container object. |
Operator | Description |
---|---|
unordered_multiset::operator= | Copies a hash table. |
The object orders the sequence it controls by calling two stored objects, a comparison function object of type unordered_multiset::key_equal and a hash function object of type unordered_multiset::hasher. You access the first stored object by calling the member function unordered_multiset::key_eq()
; and you access the second stored object by calling the member function unordered_multiset::hash_function()
. Specifically, for all values X
and Y
of type Key
, the call key_eq()(X, Y)
returns true only if the two argument values have equivalent ordering; the call hash_function()(keyval)
yields a distribution of values of type size_t
. Unlike class template unordered_set Class, an object of type unordered_multiset
does not ensure that key_eq()(X, Y)
is always false for any two elements of the controlled sequence. (Keys need not be unique.)
The object also stores a maximum load factor, which specifies the maximum desired average number of elements per bucket. If inserting an element causes unordered_multiset::load_factor()
to exceed the maximum load factor, the container increases the number of buckets and rebuilds the hash table as needed.
The actual order of elements in the controlled sequence depends on the hash function, the comparison function, the order of insertion, the maximum load factor, and the current number of buckets. You cannot in general predict the order of elements in the controlled sequence. You can always be assured, however, that any subset of elements that have equivalent ordering are adjacent in the controlled sequence.
The object allocates and frees storage for the sequence it controls through a stored allocator object of type unordered_multiset::allocator_type. Such an allocator object must have the same external interface as an object of type allocator
. Note that the stored allocator object is not copied when the container object is assigned.
Header: <unordered_set>
Namespace: std
The type of an allocator for managing storage.
typedef Alloc allocator_type;
The type is a synonym for the template parameter Alloc
.
// std__unordered_set__unordered_multiset_allocator_type.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>
typedef std::unordered_multiset<char> Myset;
typedef std::allocator<std::pair<const char, int> > Myalloc;
int main()
{
Myset c1;
Myset::allocator_type al = c1.get_allocator();
std::cout << "al == std::allocator() is "
<< std::boolalpha << (al == Myalloc()) << std::endl;
return (0);
}
al == std::allocator() is true
Designates the beginning of the controlled sequence or a bucket.
iterator begin();
const_iterator begin() const;
local_iterator begin(size_type nbucket);
const_local_iterator begin(size_type nbucket) const;
nbucket
The bucket number.
The first two member functions return a forward iterator that points at the first element of the sequence (or just beyond the end of an empty sequence). The last two member functions return a forward iterator that points at the first element of bucket nbucket (or just beyond the end of an empty bucket).
// std__unordered_set__unordered_multiset_begin.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>
typedef std::unordered_multiset<char> Myset;
int main()
{
Myset c1;
c1.insert('a');
c1.insert('b');
c1.insert('c');
// display contents "[c] [b] [a]"
for (Myset::const_iterator it = c1.begin();
it != c1.end(); ++it)
std::cout << "[" << *it << "] ";
std::cout << std::endl;
// inspect first two items "[c] [b]"
Myset::iterator it2 = c1.begin();
std::cout << "[" << *it2 << "] ";
++it2;
std::cout << "[" << *it2 << "] ";
std::cout << std::endl;
// inspect bucket containing 'a'
Myset::const_local_iterator lit = c1.begin(c1.bucket('a'));
std::cout << "[" << *lit << "] ";
return (0);
}
[c] [b] [a]
[c] [b]
[a]
Gets the bucket number for a key value.
size_type bucket(const Key& keyval) const;
keyval
The key value to map.
The member function returns the bucket number currently corresponding to the key value keyval
.
// std__unordered_set__unordered_multiset_bucket.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>
typedef std::unordered_multiset<char> Myset;
int main()
{
Myset c1;
c1.insert('a');
c1.insert('b');
c1.insert('c');
// display contents "[c] [b] [a] "
for (Myset::const_iterator it = c1.begin();
it != c1.end(); ++it)
std::cout << "[" << *it << "] ";
std::cout << std::endl;
// display buckets for keys
Myset::size_type bs = c1.bucket('a');
std::cout << "bucket('a') == " << bs << std::endl;
std::cout << "bucket_size(" << bs << ") == " << c1.bucket_size(bs)
<< std::endl;
return (0);
}
[c] [b] [a]
bucket('a') == 7
bucket_size(7) == 1
Gets the number of buckets.
size_type bucket_count() const;
The member function returns the current number of buckets.
// std__unordered_set__unordered_multiset_bucket_count.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>
typedef std::unordered_multiset<char> Myset;
int main()
{
Myset c1;
c1.insert('a');
c1.insert('b');
c1.insert('c');
// display contents "[c] [b] [a] "
for (Myset::const_iterator it = c1.begin();
it != c1.end(); ++it)
std::cout << "[" << *it << "] ";
std::cout << std::endl;
// inspect current parameters
std::cout << "bucket_count() == " << c1.bucket_count() << std::endl;
std::cout << "load_factor() == " << c1.load_factor() << std::endl;
std::cout << "max_bucket_count() == "
<< c1.max_bucket_count() << std::endl;
std::cout << "max_load_factor() == "
<< c1.max_load_factor() << std::endl;
std::cout << std::endl;
// change max_load_factor and redisplay
c1.max_load_factor(0.10f);
std::cout << "bucket_count() == " << c1.bucket_count() << std::endl;
std::cout << "load_factor() == " << c1.load_factor() << std::endl;
std::cout << "max_bucket_count() == "
<< c1.max_bucket_count() << std::endl;
std::cout << "max_load_factor() == "
<< c1.max_load_factor() << std::endl;
std::cout << std::endl;
// rehash and redisplay
c1.rehash(100);
std::cout << "bucket_count() == " << c1.bucket_count() << std::endl;
std::cout << "load_factor() == " << c1.load_factor() << std::endl;
std::cout << "max_bucket_count() == "
<< c1.max_bucket_count() << std::endl;
std::cout << "max_load_factor() == "
<< c1.max_load_factor() << std::endl;
return (0);
}
[c] [b] [a]
bucket_count() == 8
load_factor() == 0.375
max_bucket_count() == 8
max_load_factor() == 4
bucket_count() == 8
load_factor() == 0.375
max_bucket_count() == 8
max_load_factor() == 0.1
bucket_count() == 128
load_factor() == 0.0234375
max_bucket_count() == 128
max_load_factor() == 0.1
Gets the size of a bucket
size_type bucket_size(size_type nbucket) const;
nbucket
The bucket number.
The member functions returns the size of bucket number nbucket.
// std__unordered_set__unordered_multiset_bucket_size.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>
typedef std::unordered_multiset<char> Myset;
int main()
{
Myset c1;
c1.insert('a');
c1.insert('b');
c1.insert('c');
// display contents "[c] [b] [a] "
for (Myset::const_iterator it = c1.begin();
it != c1.end(); ++it)
std::cout << "[" << *it << "] ";
std::cout << std::endl;
// display buckets for keys
Myset::size_type bs = c1.bucket('a');
std::cout << "bucket('a') == " << bs << std::endl;
std::cout << "bucket_size(" << bs << ") == " << c1.bucket_size(bs)
<< std::endl;
return (0);
}
[c] [b] [a]
bucket('a') == 7
bucket_size(7) == 1
Returns a const
iterator that addresses the first element in the range.
const_iterator cbegin() const;
A const
forward-access iterator that points at the first element of the range, or the location just beyond the end of an empty range (for an empty range, cbegin() == cend()
).
With the return value of cbegin
, the elements in the range cannot be modified.
You can use this member function in place of the begin()
member function to guarantee that the return value is const_iterator
. Typically, it's used in conjunction with the auto type deduction keyword, as shown in the following example. In the example, consider Container
to be a modifiable (non- const
) container of any kind that supports begin()
and cbegin()
.
auto i1 = Container.begin();
// i1 is Container<T>::iterator
auto i2 = Container.cbegin();
// i2 is Container<T>::const_iterator
Returns a const
iterator that addresses the location just beyond the last element in a range.
const_iterator cend() const;
A const
forward-access iterator that points just beyond the end of the range.
cend
is used to test whether an iterator has passed the end of its range.
You can use this member function in place of the end()
member function to guarantee that the return value is const_iterator
. Typically, it's used in conjunction with the auto type deduction keyword, as shown in the following example. In the example, consider Container
to be a modifiable (non- const
) container of any kind that supports end()
and cend()
.
auto i1 = Container.end();
// i1 is Container<T>::iterator
auto i2 = Container.cend();
// i2 is Container<T>::const_iterator
The value returned by cend
should not be dereferenced.
Removes all elements.
void clear();
The member function calls unordered_multiset::erase(
unordered_multiset::begin(),
unordered_multiset::end())
.
// std__unordered_set__unordered_multiset_clear.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>
typedef std::unordered_multiset<char> Myset;
int main()
{
Myset c1;
c1.insert('a');
c1.insert('b');
c1.insert('c');
// display contents "[c] [b] [a] "
for (Myset::const_iterator it = c1.begin();
it != c1.end(); ++it)
std::cout << "[" << *it << "] ";
std::cout << std::endl;
// clear the container and reinspect
c1.clear();
std::cout << "size == " << c1.size() << std::endl;
std::cout << "empty() == " << std::boolalpha << c1.empty() << std::endl;
std::cout << std::endl;
c1.insert('d');
c1.insert('e');
// display contents "[e] [d] "
for (Myset::const_iterator it = c1.begin();
it != c1.end(); ++it)
std::cout << "[" << *it << "] ";
std::cout << std::endl;
std::cout << "size == " << c1.size() << std::endl;
std::cout << "empty() == " << std::boolalpha << c1.empty() << std::endl;
return (0);
}
[c] [b] [a]
size == 0
empty() == true
[e] [d]
size == 2
empty() == false
The type of a constant iterator for the controlled sequence.
typedef T1 const_iterator;
The type describes an object that can serve as a constant forward iterator for the controlled sequence. It is described here as a synonym for the implementation-defined type T1
.
// std__unordered_set__unordered_multiset_const_iterator.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>
typedef std::unordered_multiset<char> Myset;
int main()
{
Myset c1;
c1.insert('a');
c1.insert('b');
c1.insert('c');
// display contents "[c] [b] [a]"
for (Myset::const_iterator it = c1.begin();
it != c1.end(); ++it)
std::cout << "[" << *it << "] ";
std::cout << std::endl;
return (0);
}
[c] [b] [a]
The type of a constant bucket iterator for the controlled sequence.
typedef T5 const_local_iterator;
The type describes an object that can serve as a constant forward iterator for a bucket. It is described here as a synonym for the implementation-defined type T5
.
// std__unordered_set__unordered_multiset_const_local_iterator.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>
typedef std::unordered_multiset<char> Myset;
int main()
{
Myset c1;
c1.insert('a');
c1.insert('b');
c1.insert('c');
// display contents "[c] [b] [a]"
for (Myset::const_iterator it = c1.begin();
it != c1.end(); ++it)
std::cout << "[" << *it << "] ";
std::cout << std::endl;
// inspect bucket containing 'a'
Myset::const_local_iterator lit = c1.begin(c1.bucket('a'));
std::cout << "[" << *lit << "] ";
return (0);
}
[c] [b] [a]
[a]
The type of a constant pointer to an element.
typedef Alloc::const_pointer const_pointer;
The type describes an object that can serve as a constant pointer to an element of the controlled sequence.
// std__unordered_set__unordered_multiset_const_pointer.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>
typedef std::unordered_multiset<char> Myset;
int main()
{
Myset c1;
c1.insert('a');
c1.insert('b');
c1.insert('c');
// display contents "[c] [b] [a]"
for (Myset::iterator it = c1.begin();
it != c1.end(); ++it)
{
Myset::const_pointer p = &*it;
std::cout << "[" << *p << "] ";
}
std::cout << std::endl;
return (0);
}
[c] [b] [a]
The type of a constant reference to an element.
typedef Alloc::const_reference const_reference;
The type describes an object that can serve as a constant reference to an element of the controlled sequence.
// std__unordered_set__unordered_multiset_const_reference.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>
typedef std::unordered_multiset<char> Myset;
int main()
{
Myset c1;
c1.insert('a');
c1.insert('b');
c1.insert('c');
// display contents "[c] [b] [a]"
for (Myset::iterator it = c1.begin();
it != c1.end(); ++it)
{
Myset::const_reference ref = *it;
std::cout << "[" << ref << "] ";
}
std::cout << std::endl;
return (0);
}
[c] [b] [a]
Checks if there's an element with the specified key in the unordered_multiset
.
bool contains(const Key& key) const;
template<class K> bool contains(const K& key) const;
K
The type of the key.
key
The element's key value to look for.
true
if the element is found in the container; false
otherwise.
contains()
is new in C++20. To use it, specify the /std:c++20 or later compiler option.
template<class K> bool contains(const K& key) const
only participates in overload resolution if key_compare
is transparent.
// Requires /std:c++20 or /std:c++latest
#include <unordered_set>
#include <iostream>
int main()
{
std::unordered_multiset<int> theUnorderedMultiset = { 1, 2, 3 };
std::cout << std::boolalpha; // so booleans show as 'true' or 'false'
std::cout << theUnorderedMultiset.contains(1) << '\n';
std::cout << theUnorderedMultiset.contains(4) << '\n';
return 0;
}
true
false
Finds the number of elements matching a specified key.
size_type count(const Key& keyval) const;
keyval
Key value to search for.
The member function returns the number of elements in the range delimited by unordered_multiset::equal_range(keyval)
.
// std__unordered_set__unordered_multiset_count.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>
typedef std::unordered_multiset<char> Myset;
int main()
{
Myset c1;
c1.insert('a');
c1.insert('b');
c1.insert('c');
// display contents "[c] [b] [a]"
for (Myset::const_iterator it = c1.begin();
it != c1.end(); ++it)
std::cout << "[" << *it << "] ";
std::cout << std::endl;
std::cout << "count('A') == " << c1.count('A') << std::endl;
std::cout << "count('b') == " << c1.count('b') << std::endl;
std::cout << "count('C') == " << c1.count('C') << std::endl;
return (0);
}
[c] [b] [a]
count('A') == 0
count('b') == 1
count('C') == 0
The type of a signed distance between two elements.
typedef T3 difference_type;
The signed integer type describes an object that can represent the difference between the addresses of any two elements in the controlled sequence. It is described here as a synonym for the implementation-defined type T3
.
// std__unordered_set__unordered_multiset_difference_type.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>
typedef std::unordered_multiset<char> Myset;
int main()
{
Myset c1;
c1.insert('a');
c1.insert('b');
c1.insert('c');
// display contents "[c] [b] [a]"
for (Myset::const_iterator it = c1.begin();
it != c1.end(); ++it)
std::cout << "[" << *it << "] ";
std::cout << std::endl;
// compute positive difference
Myset::difference_type diff = 0;
for (Myset::const_iterator it = c1.begin();
it != c1.end(); ++it)
++diff;
std::cout << "end()-begin() == " << diff << std::endl;
// compute negative difference
diff = 0;
for (Myset::const_iterator it = c1.end();
it != c1.begin(); --it)
--diff;
std::cout << "begin()-end() == " << diff << std::endl;
return (0);
}
[c] [b] [a]
end()-begin() == 3
begin()-end() == -3
Inserts an element constructed in place (no copy or move operations are performed).
template <class... Args>
iterator emplace(Args&&... args);
args
The arguments forwarded to construct an element to be inserted into the unordered_multiset.
An iterator to the newly inserted element.
No references to container elements are invalidated by this function, but it may invalidate all iterators to the container.
During the insertion, if an exception is thrown but does not occur in the container's hash function, the container is not modified. If the exception is thrown in the hash function, the result is undefined.
For a code example, see multiset::emplace.
Inserts an element constructed in place (no copy or move operations are performed), with a placement hint.
template <class... Args>
iterator emplace_hint(
const_iterator where,
Args&&... args);
args
The arguments forwarded to construct an element to be inserted into the unordered_multiset.
where
A hint regarding the place to start searching for the correct point of insertion.
An iterator to the newly inserted element.
No references to container elements are invalidated by this function, but it may invalidate all iterators to the container.
During the insertion, if an exception is thrown but does not occur in the container's hash function, the container is not modified. If the exception is thrown in the hash function, the result is undefined.
For a code example, see set::emplace_hint.
Tests whether no elements are present.
bool empty() const;
The member function returns true for an empty controlled sequence.
// std__unordered_set__unordered_multiset_empty.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>
typedef std::unordered_multiset<char> Myset;
int main()
{
Myset c1;
c1.insert('a');
c1.insert('b');
c1.insert('c');
// display contents "[c] [b] [a]"
for (Myset::const_iterator it = c1.begin();
it != c1.end(); ++it)
std::cout << "[" << *it << "] ";
std::cout << std::endl;
// clear the container and reinspect
c1.clear();
std::cout << "size == " << c1.size() << std::endl;
std::cout << "empty() == " << std::boolalpha << c1.empty() << std::endl;
std::cout << std::endl;
c1.insert('d');
c1.insert('e');
// display contents "[e] [d]"
for (Myset::const_iterator it = c1.begin();
it != c1.end(); ++it)
std::cout << "[" << *it << "] ";
std::cout << std::endl;
std::cout << "size == " << c1.size() << std::endl;
std::cout << "empty() == " << std::boolalpha << c1.empty() << std::endl;
return (0);
}
[c] [b] [a]
size == 0
empty() == true
[e] [d]
size == 2
empty() == false
Designates the end of the controlled sequence.
iterator end();
const_iterator end() const;
local_iterator end(size_type nbucket);
const_local_iterator end(size_type nbucket) const;
nbucket
The bucket number.
The first two member functions return a forward iterator that points just beyond the end of the sequence. The last two member functions return a forward iterator that points just beyond the end of bucket nbucket.
// std__unordered_set__unordered_multiset_end.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>
typedef std::unordered_multiset<char> Myset;
int main()
{
Myset c1;
c1.insert('a');
c1.insert('b');
c1.insert('c');
// display contents "[c] [b] [a]"
for (Myset::const_iterator it = c1.begin();
it != c1.end(); ++it)
std::cout << "[" << *it << "] ";
std::cout << std::endl;
// inspect last two items "[a] [b]"
Myset::iterator it2 = c1.end();
--it2;
std::cout << "[" << *it2 << "] ";
--it2;
std::cout << "[" << *it2 << "] ";
std::cout << std::endl;
// inspect bucket containing 'a'
Myset::const_local_iterator lit = c1.end(c1.bucket('a'));
--lit;
std::cout << "[" << *lit << "] ";
return (0);
}
[c] [b] [a]
[a] [b]
[a]
Finds range that matches a specified key.
std::pair<iterator, iterator>
equal_range(const Key& keyval);
std::pair<const_iterator, const_iterator>
equal_range(const Key& keyval) const;
keyval
Key value to search for.
The member function returns a pair of iterators X
such that [X.first, X.second)
delimits just those elements of the controlled sequence that have equivalent ordering with keyval. If no such elements exist, both iterators are end()
.
// std__unordered_set__unordered_multiset_equal_range.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>
typedef std::unordered_multiset<char> Myset;
int main()
{
Myset c1;
c1.insert('a');
c1.insert('b');
c1.insert('c');
// display contents "[c] [b] [a]"
for (Myset::const_iterator it = c1.begin();
it != c1.end(); ++it)
std::cout << "[" << *it << "] ";
std::cout << std::endl;
// display results of failed search
std::pair<Myset::iterator, Myset::iterator> pair1 =
c1.equal_range('x');
std::cout << "equal_range('x'):";
for (; pair1.first != pair1.second; ++pair1.first)
std::cout << "[" << *pair1.first << "] ";
std::cout << std::endl;
// display results of successful search
pair1 = c1.equal_range('b');
std::cout << "equal_range('b'):";
for (; pair1.first != pair1.second; ++pair1.first)
std::cout << "[" << *pair1.first << "] ";
std::cout << std::endl;
return (0);
}
[c] [b] [a]
equal_range('x'):
equal_range('b'): [b]
Removes an element or a range of elements in a unordered_multiset from specified positions or removes elements that match a specified key.
iterator erase(
const_iterator Where);
iterator erase(
const_iterator First,
const_iterator Last);
size_type erase(
const key_type& Key);
Where
Position of the element to be removed.
First
Position of the first element to be removed.
Last
Position just beyond the last element to be removed.
Key
The key value of the elements to be removed.
For the first two member functions, a bidirectional iterator that designates the first element remaining beyond any elements removed, or an element that is the end of the unordered_multiset if no such element exists.
For the third member function, returns the number of elements that have been removed from the unordered_multiset.
For a code example, see set::erase.
Finds an element that matches a specified key.
const_iterator find(const Key& keyval) const;
keyval
Key value to search for.
The member function returns unordered_multiset::equal_range(keyval).first
.
// std__unordered_set__unordered_multiset_find.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>
typedef std::unordered_multiset<char> Myset;
int main()
{
Myset c1;
c1.insert('a');
c1.insert('b');
c1.insert('c');
// display contents "[c] [b] [a]"
for (Myset::const_iterator it = c1.begin();
it != c1.end(); ++it)
std::cout << "[" << *it << "] ";
std::cout << std::endl;
// try to find and fail
std::cout << "find('A') == "
<< std::boolalpha << (c1.find('A') != c1.end()) << std::endl;
// try to find and succeed
Myset::iterator it = c1.find('b');
std::cout << "find('b') == "
<< std::boolalpha << (it != c1.end())
<< ": [" << *it << "] " << std::endl;
return (0);
}
[c] [b] [a]
find('A') == false
find('b') == true: [b]
Gets the stored allocator object.
Alloc get_allocator() const;
The member function returns the stored allocator object.
// std__unordered_set__unordered_multiset_get_allocator.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>
typedef std::unordered_multiset<char> Myset;
typedef std::allocator<std::pair<const char, int> > Myalloc;
int main()
{
Myset c1;
Myset::allocator_type al = c1.get_allocator();
std::cout << "al == std::allocator() is "
<< std::boolalpha << (al == Myalloc()) << std::endl;
return (0);
}
al == std::allocator() is true
Gets the stored hash function object.
Hash hash_function() const;
The member function returns the stored hash function object.
// std__unordered_set__unordered_multiset_hash_function.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>
typedef std::unordered_multiset<char> Myset;
int main()
{
Myset c1;
Myset::hasher hfn = c1.hash_function();
std::cout << "hfn('a') == " << hfn('a') << std::endl;
std::cout << "hfn('b') == " << hfn('b') << std::endl;
return (0);
}
hfn('a') == 1630279
hfn('b') == 1647086
The type of the hash function.
typedef Hash hasher;
The type is a synonym for the template parameter Hash
.
// std__unordered_set__unordered_multiset_hasher.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>
typedef std::unordered_multiset<char> Myset;
int main()
{
Myset c1;
Myset::hasher hfn = c1.hash_function();
std::cout << "hfn('a') == " << hfn('a') << std::endl;
std::cout << "hfn('b') == " << hfn('b') << std::endl;
return (0);
}
hfn('a') == 1630279
hfn('b') == 1647086
Inserts an element or a range of elements into an unordered_multiset.
// (1) single element
pair<iterator, bool> insert(
const value_type& Val);
// (2) single element, perfect forwarded
template <class ValTy>
pair<iterator, bool>
insert(
ValTy&& Val);
// (3) single element with hint
iterator insert(
const_iterator Where,
const value_type& Val);
// (4) single element, perfect forwarded, with hint
template <class ValTy>
iterator insert(
const_iterator Where,
ValTy&& Val);
// (5) range
template <class InputIterator>
void insert(
InputIterator First,
InputIterator Last);
// (6) initializer list
void insert(
initializer_list<value_type>
IList);
Val
The value of an element to be inserted into the unordered_multiset.
Where
The place to start searching for the correct point of insertion.
ValTy
Template parameter that specifies the argument type that the unordered_multiset can use to construct an element of value_type, and perfect-forwards Val as an argument.
First
The position of the first element to be copied.
Last
The position just beyond the last element to be copied.
InputIterator
Template function argument that meets the requirements of an input iterator that points to elements of a type that can be used to construct value_type objects.
IList
The initializer_list from which to copy the elements.
The single-element-insert member functions, (1) and (2), return an iterator to the position where the new element was inserted into the unordered_multiset.
The single-element-with-hint member functions, (3) and (4), return an iterator that points to the position where the new element was inserted into the unordered_multiset.
No pointers or references are invalidated by this function, but it may invalidate all iterators to the container.
During the insertion of just one element, if an exception is thrown but does not occur in the container's hash function, the container's state is not modified. If the exception is thrown in the hash function, the result is undefined. During the insertion of multiple elements, if an exception is thrown, the container is left in an unspecified but valid state.
The value_type of a container is a typedef that belongs to the container, and, for set, unordered_multiset<V>::value_type
is type const V
.
The range member function (5) inserts the sequence of element values into an unordered_multiset that corresponds to each element addressed by an iterator in the range [First, Last)
; therefore, Last does not get inserted. The container member function end()
refers to the position just after the last element in the container—for example, the statement m.insert(v.begin(), v.end());
inserts all elements of v
into m
.
The initializer list member function (6) uses an initializer_list to copy elements into the unordered_multiset.
For insertion of an element constructed in place—that is, no copy or move operations are performed—see unordered_multiset::emplace and unordered_multiset::emplace_hint.
For a code example, see multiset::insert.
A type that provides a constant forward iterator that can read elements in an unordered_multiset.
typedef implementation-defined iterator;
See the example for begin for an example of how to declare and use an iterator.
Gets the stored comparison function object.
Pred key_eq() const;
The member function returns the stored comparison function object.
// std__unordered_set__unordered_multiset_key_eq.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>
typedef std::unordered_multiset<char> Myset;
int main()
{
Myset c1;
Myset::key_equal cmpfn = c1.key_eq();
std::cout << "cmpfn('a', 'a') == "
<< std::boolalpha << cmpfn('a', 'a') << std::endl;
std::cout << "cmpfn('a', 'b') == "
<< std::boolalpha << cmpfn('a', 'b') << std::endl;
return (0);
}
cmpfn('a', 'a') == true
cmpfn('a', 'b') == false
The type of the comparison function.
typedef Pred key_equal;
The type is a synonym for the template parameter Pred
.
// std__unordered_set__unordered_multiset_key_equal.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>
typedef std::unordered_multiset<char> Myset;
int main()
{
Myset c1;
Myset::key_equal cmpfn = c1.key_eq();
std::cout << "cmpfn('a', 'a') == "
<< std::boolalpha << cmpfn('a', 'a') << std::endl;
std::cout << "cmpfn('a', 'b') == "
<< std::boolalpha << cmpfn('a', 'b') << std::endl;
return (0);
}
cmpfn('a', 'a') == true
cmpfn('a', 'b') == false
The type of an ordering key.
typedef Key key_type;
The type is a synonym for the template parameter Key
.
// std__unordered_set__unordered_multiset_key_type.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>
typedef std::unordered_multiset<char> Myset;
int main()
{
Myset c1;
c1.insert('a');
c1.insert('b');
c1.insert('c');
// display contents "[c] [b] [a]"
for (Myset::const_iterator it = c1.begin();
it != c1.end(); ++it)
std::cout << "[" << *it << "] ";
std::cout << std::endl;
// add a value and reinspect
Myset::key_type key = 'd';
Myset::value_type val = key;
c1.insert(val);
for (Myset::const_iterator it = c1.begin();
it != c1.end(); ++it)
std::cout << "[" << *it << "] ";
std::cout << std::endl;
return (0);
}
[c] [b] [a]
[d] [c] [b] [a]
Counts the average elements per bucket.
float load_factor() const;
The member function returns (float)
unordered_multiset::size() / (float)
unordered_multiset::bucket_count()
, the average number of elements per bucket.
// std__unordered_set__unordered_multiset_load_factor.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>
typedef std::unordered_multiset<char> Myset;
int main()
{
Myset c1;
c1.insert('a');
c1.insert('b');
c1.insert('c');
// display contents "[c] [b] [a]"
for (Myset::const_iterator it = c1.begin();
it != c1.end(); ++it)
std::cout << "[" << *it << "] ";
std::cout << std::endl;
// inspect current parameters
std::cout << "bucket_count() == " << c1.bucket_count() << std::endl;
std::cout << "load_factor() == " << c1.load_factor() << std::endl;
std::cout << "max_bucket_count() == "
<< c1.max_bucket_count() << std::endl;
std::cout << "max_load_factor() == "
<< c1.max_load_factor() << std::endl;
std::cout << std::endl;
// change max_load_factor and redisplay
c1.max_load_factor(0.10f);
std::cout << "bucket_count() == " << c1.bucket_count() << std::endl;
std::cout << "load_factor() == " << c1.load_factor() << std::endl;
std::cout << "max_bucket_count() == "
<< c1.max_bucket_count() << std::endl;
std::cout << "max_load_factor() == "
<< c1.max_load_factor() << std::endl;
std::cout << std::endl;
// rehash and redisplay
c1.rehash(100);
std::cout << "bucket_count() == " << c1.bucket_count() << std::endl;
std::cout << "load_factor() == " << c1.load_factor() << std::endl;
std::cout << "max_bucket_count() == "
<< c1.max_bucket_count() << std::endl;
std::cout << "max_load_factor() == "
<< c1.max_load_factor() << std::endl;
std::cout << std::endl;
return (0);
}
The type of a bucket iterator.
typedef T4 local_iterator;
The type describes an object that can serve as a forward iterator for a bucket. It is described here as a synonym for the implementation-defined type T4
.
// std__unordered_set__unordered_multiset_local_iterator.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>
typedef std::unordered_multiset<char> Myset;
int main()
{
Myset c1;
c1.insert('a');
c1.insert('b');
c1.insert('c');
// display contents "[c] [b] [a]"
for (Myset::const_iterator it = c1.begin();
it != c1.end(); ++it)
std::cout << "[" << *it << "] ";
std::cout << std::endl;
// inspect bucket containing 'a'
Myset::local_iterator lit = c1.begin(c1.bucket('a'));
std::cout << "[" << *lit << "] ";
return (0);
}
[c] [b] [a]
[a]
Gets the maximum number of buckets.
size_type max_bucket_count() const;
The member function returns the maximum number of buckets currently permitted.
// std__unordered_set__unordered_multiset_max_bucket_count.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>
typedef std::unordered_multiset<char> Myset;
int main()
{
Myset c1;
c1.insert('a');
c1.insert('b');
c1.insert('c');
// display contents "[c] [b] [a]"
for (Myset::const_iterator it = c1.begin();
it != c1.end(); ++it)
std::cout << "[" << *it << "] ";
std::cout << std::endl;
// inspect current parameters
std::cout << "bucket_count() == " << c1.bucket_count() << std::endl;
std::cout << "load_factor() == " << c1.load_factor() << std::endl;
std::cout << "max_bucket_count() == "
<< c1.max_bucket_count() << std::endl;
std::cout << "max_load_factor() == "
<< c1.max_load_factor() << std::endl;
std::cout << std::endl;
// change max_load_factor and redisplay
c1.max_load_factor(0.10f);
std::cout << "bucket_count() == " << c1.bucket_count() << std::endl;
std::cout << "load_factor() == " << c1.load_factor() << std::endl;
std::cout << "max_bucket_count() == "
<< c1.max_bucket_count() << std::endl;
std::cout << "max_load_factor() == "
<< c1.max_load_factor() << std::endl;
std::cout << std::endl;
// rehash and redisplay
c1.rehash(100);
std::cout << "bucket_count() == " << c1.bucket_count() << std::endl;
std::cout << "load_factor() == " << c1.load_factor() << std::endl;
std::cout << "max_bucket_count() == "
<< c1.max_bucket_count() << std::endl;
std::cout << "max_load_factor() == "
<< c1.max_load_factor() << std::endl;
std::cout << std::endl;
return (0);
}
[c] [b] [a]
bucket_count() == 8
load_factor() == 0.375
max_bucket_count() == 8
max_load_factor() == 4
bucket_count() == 8
load_factor() == 0.375
max_bucket_count() == 8
max_load_factor() == 0.1
bucket_count() == 128
load_factor() == 0.0234375
max_bucket_count() == 128
max_load_factor() == 0.1
Gets or sets the maximum elements per bucket.
float max_load_factor() const;
void max_load_factor(float factor);
factor
The new maximum load factor.
The first member function returns the stored maximum load factor. The second member function replaces the stored maximum load factor with factor.
// std__unordered_set__unordered_multiset_max_load_factor.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>
typedef std::unordered_multiset<char> Myset;
int main()
{
Myset c1;
c1.insert('a');
c1.insert('b');
c1.insert('c');
// display contents "[c] [b] [a]"
for (Myset::const_iterator it = c1.begin();
it != c1.end(); ++it)
std::cout << "[" << *it << "] ";
std::cout << std::endl;
// inspect current parameters
std::cout << "bucket_count() == " << c1.bucket_count() << std::endl;
std::cout << "load_factor() == " << c1.load_factor() << std::endl;
std::cout << "max_bucket_count() == "
<< c1.max_bucket_count() << std::endl;
std::cout << "max_load_factor() == "
<< c1.max_load_factor() << std::endl;
std::cout << std::endl;
// change max_load_factor and redisplay
c1.max_load_factor(0.10f);
std::cout << "bucket_count() == " << c1.bucket_count() << std::endl;
std::cout << "load_factor() == " << c1.load_factor() << std::endl;
std::cout << "max_bucket_count() == "
<< c1.max_bucket_count() << std::endl;
std::cout << "max_load_factor() == "
<< c1.max_load_factor() << std::endl;
std::cout << std::endl;
// rehash and redisplay
c1.rehash(100);
std::cout << "bucket_count() == " << c1.bucket_count() << std::endl;
std::cout << "load_factor() == " << c1.load_factor() << std::endl;
std::cout << "max_bucket_count() == "
<< c1.max_bucket_count() << std::endl;
std::cout << "max_load_factor() == "
<< c1.max_load_factor() << std::endl;
std::cout << std::endl;
return (0);
}
[c] [b] [a]
bucket_count() == 8
load_factor() == 0.375
max_bucket_count() == 8
max_load_factor() == 4
bucket_count() == 8
load_factor() == 0.375
max_bucket_count() == 8
max_load_factor() == 0.1
bucket_count() == 128
load_factor() == 0.0234375
max_bucket_count() == 128
max_load_factor() == 0.1
Gets the maximum size of the controlled sequence.
size_type max_size() const;
The member function returns the length of the longest sequence that the object can control.
// std__unordered_set__unordered_multiset_max_size.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>
typedef std::unordered_multiset<char> Myset;
int main()
{
Myset c1;
std::cout << "max_size() == " << c1.max_size() << std::endl;
return (0);
}
max_size() == 4294967295
Copies a hash table.
unordered_multiset& operator=(const unordered_multiset& right);
unordered_multiset& operator=(unordered_multiset&& right);
right
The unordered_multiset being copied into the unordered_multiset
.
After erasing any existing elements in an unordered_multiset
, operator=
either copies or moves the contents of right into the unordered_multiset
.
// unordered_multiset_operator_as.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>
int main( )
{
using namespace std;
unordered_multiset<int> v1, v2, v3;
unordered_multiset<int>::iterator iter;
v1.insert(10);
cout << "v1 = " ;
for (iter = v1.begin(); iter != v1.end(); iter++)
cout << *iter << " ";
cout << endl;
v2 = v1;
cout << "v2 = ";
for (iter = v2.begin(); iter != v2.end(); iter++)
cout << *iter << " ";
cout << endl;
// move v1 into v2
v2.clear();
v2 = move(v1);
cout << "v2 = ";
for (iter = v2.begin(); iter != v2.end(); iter++)
cout << *iter << " ";
cout << endl;
}
The type of a pointer to an element.
typedef Alloc::pointer pointer;
The type describes an object that can serve as a pointer to an element of the controlled sequence.
// std__unordered_set__unordered_multiset_pointer.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>
typedef std::unordered_multiset<char> Myset;
int main()
{
Myset c1;
c1.insert('a');
c1.insert('b');
c1.insert('c');
// display contents "[c] [b] [a]"
for (Myset::iterator it = c1.begin();
it != c1.end(); ++it)
{
Myset::key_type key = *it;
Myset::pointer p = &key;
std::cout << "[" << *p << "] ";
}
std::cout << std::endl;
return (0);
}
[c] [b] [a]
The type of a reference to an element.
typedef Alloc::reference reference;
The type describes an object that can serve as a reference to an element of the controlled sequence.
// std__unordered_set__unordered_multiset_reference.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>
typedef std::unordered_multiset<char> Myset;
int main()
{
Myset c1;
c1.insert('a');
c1.insert('b');
c1.insert('c');
// display contents "[c] [b] [a]"
for (Myset::iterator it = c1.begin();
it != c1.end(); ++it)
{
Myset::key_type key = *it;
Myset::reference ref = key;
std::cout << "[" << ref << "] ";
}
std::cout << std::endl;
return (0);
}
[c] [b] [a]
Rebuilds the hash table.
void rehash(size_type nbuckets);
nbuckets
The requested number of buckets.
The member function alters the number of buckets to be at least nbuckets and rebuilds the hash table as needed.
// std__unordered_set__unordered_multiset_rehash.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>
typedef std::unordered_multiset<char> Myset;
int main()
{
Myset c1;
c1.insert('a');
c1.insert('b');
c1.insert('c');
// display contents "[c] [b] [a]"
for (Myset::const_iterator it = c1.begin();
it != c1.end(); ++it)
std::cout << "[" << *it << "] ";
std::cout << std::endl;
// inspect current parameters
std::cout << "bucket_count() == " << c1.bucket_count() << std::endl;
std::cout << "load_factor() == " << c1.load_factor() << std::endl;
std::cout << "max_load_factor() == " << c1.max_load_factor() << std::endl;
std::cout << std::endl;
// change max_load_factor and redisplay
c1.max_load_factor(0.10f);
std::cout << "bucket_count() == " << c1.bucket_count() << std::endl;
std::cout << "load_factor() == " << c1.load_factor() << std::endl;
std::cout << "max_load_factor() == " << c1.max_load_factor() << std::endl;
std::cout << std::endl;
// rehash and redisplay
c1.rehash(100);
std::cout << "bucket_count() == " << c1.bucket_count() << std::endl;
std::cout << "load_factor() == " << c1.load_factor() << std::endl;
std::cout << "max_load_factor() == " << c1.max_load_factor() << std::endl;
return (0);
}
[c] [b] [a]
bucket_count() == 8
load_factor() == 0.375
max_load_factor() == 4
bucket_count() == 8
load_factor() == 0.375
max_load_factor() == 0.1
bucket_count() == 128
load_factor() == 0.0234375
max_load_factor() == 0.1
Counts the number of elements.
size_type size() const;
The member function returns the length of the controlled sequence.
// std__unordered_set__unordered_multiset_size.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>
typedef std::unordered_multiset<char> Myset;
int main()
{
Myset c1;
c1.insert('a');
c1.insert('b');
c1.insert('c');
// display contents "[c] [b] [a]"
for (Myset::const_iterator it = c1.begin();
it != c1.end(); ++it)
std::cout << "[" << *it << "] ";
std::cout << std::endl;
// clear the container and reinspect
c1.clear();
std::cout << "size == " << c1.size() << std::endl;
std::cout << "empty() == " << std::boolalpha << c1.empty() << std::endl;
std::cout << std::endl;
c1.insert('d');
c1.insert('e');
// display contents "[e] [d]"
for (Myset::const_iterator it = c1.begin();
it != c1.end(); ++it)
std::cout << "[" << *it << "] ";
std::cout << std::endl;
std::cout << "size == " << c1.size() << std::endl;
std::cout << "empty() == " << std::boolalpha << c1.empty() << std::endl;
return (0);
}
[c] [b] [a]
size == 0
empty() == true
[e] [d]
size == 2
empty() == false
The type of an unsigned distance between two elements.
typedef T2 size_type;
The unsigned integer type describes an object that can represent the length of any controlled sequence. It is described here as a synonym for the implementation-defined type T2
.
// std__unordered_set__unordered_multiset_size_type.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>
typedef std::unordered_multiset<char> Myset;
int main()
{
Myset c1;
Myset::size_type sz = c1.size();
std::cout << "size == " << sz << std::endl;
return (0);
}
size == 0
Swaps the contents of two containers.
void swap(unordered_multiset& right);
right
The container to swap with.
The member function swaps the controlled sequences between *this
and right. If unordered_multiset::get_allocator() == right.get_allocator()
, it does so in constant time, it throws an exception only as a result of copying the stored traits object of type Tr
, and it invalidates no references, pointers, or iterators that designate elements in the two controlled sequences. Otherwise, it performs a number of element assignments and constructor calls proportional to the number of elements in the two controlled sequences.
// std__unordered_set__unordered_multiset_swap.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>
typedef std::unordered_multiset<char> Myset;
int main()
{
Myset c1;
c1.insert('a');
c1.insert('b');
c1.insert('c');
// display contents "[c] [b] [a]"
for (Myset::const_iterator it = c1.begin();
it != c1.end(); ++it)
std::cout << "[" << *it << "] ";
std::cout << std::endl;
Myset c2;
c2.insert('d');
c2.insert('e');
c2.insert('f');
c1.swap(c2);
// display contents "[f] [e] [d]"
for (Myset::const_iterator it = c1.begin();
it != c1.end(); ++it)
std::cout << "[" << *it << "] ";
std::cout << std::endl;
swap(c1, c2);
// display contents "[c] [b] [a]"
for (Myset::const_iterator it = c1.begin();
it != c1.end(); ++it)
std::cout << "[" << *it << "] ";
std::cout << std::endl;
return (0);
}
[c] [b] [a]
[f] [e] [d]
[c] [b] [a]
Constructs a container object.
unordered_multiset(
const unordered_multiset& Right);
explicit unordered_multiset(
size_type Bucket_count = N0,
const Hash& Hash = Hash(),
const Comp& Comp = Comp(),
const Allocator& Al = Alloc());
unordered_multiset(
unordered_multiset&& Right);
unordered_set(
initializer_list<Type> IList);
unordered_set(
initializer_list<Typ> IList,
size_type Bucket_count);
unordered_set(
initializer_list<Type> IList,
size_type Bucket_count,
const Hash& Hash);
unordered_set(
initializer_list<Type> IList,
size_type Bucket_count,
const Hash& Hash,
const Key& Key);
unordered_set(
initializer_list<Type> IList,
size_type Bucket_count,
const Hash& Hash,
const Key& Key,
const Allocator& Al);
template <class InputIterator>
unordered_multiset(
InputIterator First,
InputIterator Last,
size_type Bucket_count = N0,
const Hash& Hash = Hash(),
const Comp& Comp = Comp(),
const Allocator& Al = Alloc());
InputIterator
The iterator type.
Al
The allocator object to store.
Comp
The comparison function object to store.
Hash
The hash function object to store.
Bucket_count
The minimum number of buckets.
Right
The container to copy.
IList
The initializer_list from which to copy.
The first constructor specifies a copy of the sequence controlled by Right. The second constructor specifies an empty controlled sequence. The third constructor inserts the sequence of element values [First, Last)
. The fourth constructor specifies a copy of the sequence by moving Right.
All constructors also initialize several stored values. For the copy constructor, the values are obtained from Right. Otherwise:
The minimum number of buckets is the argument Bucket_count, if present; otherwise it is a default value described here as the implementation-defined value N0
.
The hash function object is the argument Hash, if present; otherwise it is Hash()
.
The comparison function object is the argument Comp, if present; otherwise it is Comp()
.
The allocator object is the argument Al, if present; otherwise, it is Alloc()
.
The type of an element.
typedef Key value_type;
The type describes an element of the controlled sequence.
// std__unordered_set__unordered_multiset_value_type.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>
typedef std::unordered_multiset<char> Myset;
int main()
{
Myset c1;
c1.insert('a');
c1.insert('b');
c1.insert('c');
// display contents "[c] [b] [a]"
for (Myset::const_iterator it = c1.begin();
it != c1.end(); ++it)
std::cout << "[" << *it << "] ";
std::cout << std::endl;
// add a value and reinspect
Myset::key_type key = 'd';
Myset::value_type val = key;
c1.insert(val);
for (Myset::const_iterator it = c1.begin();
it != c1.end(); ++it)
std::cout << "[" << *it << "] ";
std::cout << std::endl;
return (0);
}
[c] [b] [a]
[d] [c] [b] [a]
<unordered_set>
Containers
Thread Safety in the C++ Standard Library
C++ Standard Library Reference