STLdoc: unordered_set< _Kty, _Hasher, _Keyeq, _Alloc > Class Template Reference

STLdoc

STLdocumentation

All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros

Inheritance diagram for unordered_set< _Kty, _Hasher, _Keyeq, _Alloc >:

Public Types
typedef unordered_set< _Kty, _Hasher, _Keyeq, _Alloc >	_Myt

typedef _Uhash_compare< _Kty, _Hasher, _Keyeq >	_Mytraits

typedef _Hash< _Uset_traits< _Kty, _Mytraits, _Alloc, false > >	_Mybase

typedef _Hasher	hasher

typedef _Kty	key_type

typedef _Keyeq	key_equal

typedef _Mytraits	key_compare

typedef _Mybase::allocator_type	allocator_type

typedef _Mybase::size_type	size_type

typedef _Mybase::difference_type	difference_type

typedef _Mybase::pointer	pointer

typedef _Mybase::const_pointer	const_pointer

typedef _Mybase::reference	reference

typedef _Mybase::const_reference	const_reference

typedef _Mybase::iterator	iterator

typedef _Mybase::const_iterator	const_iterator

typedef _Mybase::value_type	value_type

typedef _Mybase::iterator	local_iterator

typedef _Mybase::const_iterator	const_local_iterator

typedef _Mybase::_Alty	_Alty

Public Types inherited from _Hash< _Uset_traits< _Kty, _Uhash_compare< _Kty, _Hasher, _Keyeq >, _Alloc, false > >
enum

typedef _Hash< _Uset_traits< _Kty, _Uhash_compare< _Kty, _Hasher, _Keyeq >, _Alloc, false > >	_Myt

typedef _Uset_traits< _Kty, _Uhash_compare< _Kty, _Hasher, _Keyeq >, _Alloc, false >::key_type	key_type

typedef _Uset_traits< _Kty, _Uhash_compare< _Kty, _Hasher, _Keyeq >, _Alloc, false >::key_compare	key_compare

typedef _Uset_traits< _Kty, _Uhash_compare< _Kty, _Hasher, _Keyeq >, _Alloc, false >::value_compare	value_compare

typedef list< typename _Uset_traits< _Kty, _Uhash_compare< _Kty, _Hasher, _Keyeq >, _Alloc, false >::value_type, typename _Uset_traits< _Kty, _Uhash_compare< _Kty, _Hasher, _Keyeq >, _Alloc, false >::allocator_type >	_Mylist

typedef _Mylist::_Alty	_Alty

typedef _Mylist::value_type	value_type

typedef _Mylist::allocator_type	allocator_type

typedef _Mylist::size_type	size_type

typedef _Mylist::difference_type	difference_type

typedef _Mylist::pointer	pointer

typedef _Mylist::const_pointer	const_pointer

typedef _Mylist::reference	reference

typedef _Mylist::const_reference	const_reference

typedef _If< is_same< key_type, value_type >::value, typename _Mylist::const_iterator, typename _Mylist::iterator >::type	iterator

typedef _Mylist::const_iterator	const_iterator

typedef _If< is_same< key_type, value_type >::value, typename _Mylist::_Unchecked_const_iterator, typename _Mylist::_Unchecked_iterator >::type	_Unchecked_iterator

typedef _Mylist::_Unchecked_const_iterator	_Unchecked_const_iterator

typedef vector< _Unchecked_iterator, typename _Alty::template rebind< _Unchecked_iterator >::other >	_Myvec

typedef pair< iterator, bool >	_Pairib

typedef pair< iterator, iterator >	_Pairii

typedef pair< const_iterator, const_iterator >	_Paircc

typedef iterator	local_iterator

typedef const_iterator	const_local_iterator

Public Member Functions
	unordered_set ()

	unordered_set (const allocator_type &_Al)

	unordered_set (const _Myt &_Right)

	unordered_set (const _Myt &_Right, const allocator_type &_Al)

	unordered_set (size_type _Buckets)

	unordered_set (size_type _Buckets, const allocator_type &_Al)

	unordered_set (size_type _Buckets, const hasher &_Hasharg)

	unordered_set (size_type _Buckets, const hasher &_Hasharg, const allocator_type &_Al)

	unordered_set (size_type _Buckets, const hasher &_Hasharg, const _Keyeq &_Keyeqarg)

	unordered_set (size_type _Buckets, const hasher &_Hasharg, const _Keyeq &_Keyeqarg, const allocator_type &_Al)

template<class _Iter >
	unordered_set (_Iter _First, _Iter _Last)

template<class _Iter >
	unordered_set (_Iter _First, _Iter _Last, const allocator_type &_Al)

template<class _Iter >
	unordered_set (_Iter _First, _Iter _Last, size_type _Buckets)

template<class _Iter >
	unordered_set (_Iter _First, _Iter _Last, size_type _Buckets, const allocator_type &_Al)

template<class _Iter >
	unordered_set (_Iter _First, _Iter _Last, size_type _Buckets, const hasher &_Hasharg)

template<class _Iter >
	unordered_set (_Iter _First, _Iter _Last, size_type _Buckets, const hasher &_Hasharg, const allocator_type &_Al)

template<class _Iter >
	unordered_set (_Iter _First, _Iter _Last, size_type _Buckets, const hasher &_Hasharg, const _Keyeq &_Keyeqarg)

template<class _Iter >
	unordered_set (_Iter _First, _Iter _Last, size_type _Buckets, const hasher &_Hasharg, const _Keyeq &_Keyeqarg, const allocator_type &_Al)

_Myt &	operator= (const _Myt &_Right)

	unordered_set (_Myt &&_Right)

	unordered_set (_Myt &&_Right, const allocator_type &_Al)

_Myt &	operator= (_Myt &&_Right) _NOEXCEPT_OP(_Alty

void	swap (_Myt &_Right) _NOEXCEPT_OP(_Alty

	unordered_set (initializer_list< value_type > _Ilist)

	unordered_set (initializer_list< value_type > _Ilist, const allocator_type &_Al)

	unordered_set (initializer_list< value_type > _Ilist, size_type _Buckets)

	unordered_set (initializer_list< value_type > _Ilist, size_type _Buckets, const allocator_type &_Al)

	unordered_set (initializer_list< value_type > _Ilist, size_type _Buckets, const hasher &_Hasharg)

	unordered_set (initializer_list< value_type > _Ilist, size_type _Buckets, const hasher &_Hasharg, const allocator_type &_Al)

	unordered_set (initializer_list< value_type > _Ilist, size_type _Buckets, const hasher &_Hasharg, const _Keyeq &_Keyeqarg)

	unordered_set (initializer_list< value_type > _Ilist, size_type _Buckets, const hasher &_Hasharg, const _Keyeq &_Keyeqarg, const allocator_type &_Al)

_Myt &	operator= (initializer_list< value_type > _Ilist)

hasher	hash_function () const

key_equal	key_eq () const

Public Member Functions inherited from _Hash< _Uset_traits< _Kty, _Uhash_compare< _Kty, _Hasher, _Keyeq >, _Alloc, false > >
	_Hash (const key_compare &_Parg, const allocator_type &_Al)

	_Hash (const _Myt &_Right, const _Any_alloc &_Al)

	_Hash (_Myt &&_Right)

	_Hash (_Myt &&_Right, const allocator_type &_Al)

void	_Move_nodes (_Iter _First, _Iter _Last, true_type)

void	_Move_nodes (_Iter _First, _Iter _Last, false_type)

void	_Move_assign_list (_Other &_Right, true_type)

void	_Move_assign_list (_Other &_Right, false_type)

_Myt &	operator= (_Myt &&_Right)

_Myt &	operator= (const _Myt &_Right)

_Pairib	emplace (_Valty &&..._Val)

iterator	emplace_hint (const_iterator, _Valty &&..._Val)

	~_Hash () _NOEXCEPT

iterator	begin () _NOEXCEPT

const_iterator	begin () const _NOEXCEPT

local_iterator	begin (size_type _Bucket)

const_local_iterator	begin (size_type _Bucket) const

iterator	end () _NOEXCEPT

const_iterator	end () const _NOEXCEPT

local_iterator	end (size_type _Bucket)

const_local_iterator	end (size_type _Bucket) const

_Unchecked_iterator	_Unchecked_begin ()

_Unchecked_const_iterator	_Unchecked_begin () const

_Unchecked_iterator	_Unchecked_end ()

_Unchecked_const_iterator	_Unchecked_end () const

iterator	_Make_iter (_Unchecked_const_iterator _Where) const

iterator	_Make_iter (const_iterator _Where) const

const_iterator	cbegin () const _NOEXCEPT

const_local_iterator	cbegin (size_type _Bucket) const

const_iterator	cend () const _NOEXCEPT

const_local_iterator	cend (size_type _Bucket) const

size_type	size () const _NOEXCEPT

size_type	max_size () const _NOEXCEPT

bool	empty () const _NOEXCEPT

allocator_type	get_allocator () const _NOEXCEPT

key_compare	key_comp () const

value_compare	value_comp () const

size_type	bucket_count () const _NOEXCEPT

size_type	max_bucket_count () const _NOEXCEPT

size_type	bucket (const key_type &_Keyval) const

size_type	bucket_size (size_type _Bucket) const

float	load_factor () const _NOEXCEPT

float	max_load_factor () const _NOEXCEPT

void	max_load_factor (float _Newmax)

void	rehash (size_type _Buckets)

void	reserve (size_type _Maxcount)

_Pairib	insert (const value_type &_Val)

iterator	insert (const value_type &_Val)

_Pairib	insert (value_type &&_Val)

iterator	insert (value_type &&_Val)

iterator	insert (const_iterator, const value_type &_Val)

iterator	insert (const_iterator, value_type &&_Val)

void	insert (_Iter _First, _Iter _Last)

void	insert (initializer_list< value_type > _Ilist)

iterator	erase (const_iterator _Plist)

iterator	erase (const_iterator _First, const_iterator _Last)

size_type	erase (const key_type &_Keyval)

void	clear () _NOEXCEPT

iterator	find (const key_type &_Keyval)

const_iterator	find (const key_type &_Keyval) const

size_type	count (const key_type &_Keyval) const

iterator	lower_bound (const key_type &_Keyval)

const_iterator	lower_bound (const key_type &_Keyval) const

iterator	upper_bound (const key_type &_Keyval)

const_iterator	upper_bound (const key_type &_Keyval) const

_Pairii	equal_range (const key_type &_Keyval)

_Paircc	equal_range (const key_type &_Keyval) const

void	swap (_Myt &_Right)

Additional Inherited Members
Protected Member Functions inherited from _Hash< _Uset_traits< _Kty, _Uhash_compare< _Kty, _Hasher, _Keyeq >, _Alloc, false > >
_Unchecked_iterator	_Buynode_if_nil (_Valty &&, _Unchecked_iterator _Plist)

_Unchecked_iterator	_Buynode_if_nil (_Valty &&_Val, _Nil)

void	_Destroy_if_not_nil (_Unchecked_iterator _Plist)

void	_Destroy_if_not_nil (_Nil)

_Pairib	_Insert (_Valty &&_Val, _Nodety _Pnode)

_Unchecked_iterator &	_Vec_lo (size_type _Bucket)

_Unchecked_const_iterator &	_Vec_lo (size_type _Bucket) const

_Unchecked_iterator &	_Vec_hi (size_type _Bucket)

_Unchecked_const_iterator &	_Vec_hi (size_type _Bucket) const

_Unchecked_iterator	_Begin (size_type _Bucket)

_Unchecked_const_iterator	_Begin (size_type _Bucket) const

_Unchecked_iterator	_End (size_type _Bucket)

_Unchecked_const_iterator	_End (size_type _Bucket) const

void	_Erase_bucket (iterator _Plist_arg, size_type _Bucket)

void	_Insert_bucket (_Unchecked_iterator _Plist, _Unchecked_iterator _Where, size_type _Bucket)

void	_Copy (const _Myt &_Right)

size_type	_Hashval (const key_type &_Keyval) const

void	_Init (size_type _Buckets=_Min_buckets)

void	_Check_size ()

void	_Reinsert ()

float &	_Max_bucket_size () _NOEXCEPT

const float &	_Max_bucket_size () const _NOEXCEPT

Protected Attributes inherited from _Hash< _Uset_traits< _Kty, _Uhash_compare< _Kty, _Hasher, _Keyeq >, _Alloc, false > >
_Uset_traits< _Kty, _Uhash_compare< _Kty, _Hasher, _Keyeq >, _Alloc, false >	_Traitsobj

_Mylist	_List

_Myvec	_Vec

size_type	_Mask

size_type	_Maxidx

Member Typedef Documentation

template<class _Kty, class _Hasher = hash<_Kty>, class _Keyeq = equal_to<_Kty>, class _Alloc = allocator<_Kty>>

typedef _Mybase::_Alty unordered_set< _Kty, _Hasher, _Keyeq, _Alloc >::_Alty

template<class _Kty, class _Hasher = hash<_Kty>, class _Keyeq = equal_to<_Kty>, class _Alloc = allocator<_Kty>>

typedef _Hash<_Uset_traits<_Kty, _Mytraits, _Alloc, false> > unordered_set< _Kty, _Hasher, _Keyeq, _Alloc >::_Mybase

template<class _Kty, class _Hasher = hash<_Kty>, class _Keyeq = equal_to<_Kty>, class _Alloc = allocator<_Kty>>

typedef unordered_set<_Kty, _Hasher, _Keyeq, _Alloc> unordered_set< _Kty, _Hasher, _Keyeq, _Alloc >::_Myt

template<class _Kty, class _Hasher = hash<_Kty>, class _Keyeq = equal_to<_Kty>, class _Alloc = allocator<_Kty>>

typedef _Uhash_compare<_Kty, _Hasher, _Keyeq> unordered_set< _Kty, _Hasher, _Keyeq, _Alloc >::_Mytraits

template<class _Kty, class _Hasher = hash<_Kty>, class _Keyeq = equal_to<_Kty>, class _Alloc = allocator<_Kty>>

typedef _Mybase::allocator_type unordered_set< _Kty, _Hasher, _Keyeq, _Alloc >::allocator_type

template<class _Kty, class _Hasher = hash<_Kty>, class _Keyeq = equal_to<_Kty>, class _Alloc = allocator<_Kty>>

typedef _Mybase::const_iterator unordered_set< _Kty, _Hasher, _Keyeq, _Alloc >::const_iterator

template<class _Kty, class _Hasher = hash<_Kty>, class _Keyeq = equal_to<_Kty>, class _Alloc = allocator<_Kty>>

typedef _Mybase::const_iterator unordered_set< _Kty, _Hasher, _Keyeq, _Alloc >::const_local_iterator

template<class _Kty, class _Hasher = hash<_Kty>, class _Keyeq = equal_to<_Kty>, class _Alloc = allocator<_Kty>>

typedef _Mybase::const_pointer unordered_set< _Kty, _Hasher, _Keyeq, _Alloc >::const_pointer

template<class _Kty, class _Hasher = hash<_Kty>, class _Keyeq = equal_to<_Kty>, class _Alloc = allocator<_Kty>>

typedef _Mybase::const_reference unordered_set< _Kty, _Hasher, _Keyeq, _Alloc >::const_reference

template<class _Kty, class _Hasher = hash<_Kty>, class _Keyeq = equal_to<_Kty>, class _Alloc = allocator<_Kty>>

typedef _Mybase::difference_type unordered_set< _Kty, _Hasher, _Keyeq, _Alloc >::difference_type

template<class _Kty, class _Hasher = hash<_Kty>, class _Keyeq = equal_to<_Kty>, class _Alloc = allocator<_Kty>>

typedef _Hasher unordered_set< _Kty, _Hasher, _Keyeq, _Alloc >::hasher

template<class _Kty, class _Hasher = hash<_Kty>, class _Keyeq = equal_to<_Kty>, class _Alloc = allocator<_Kty>>

typedef _Mybase::iterator unordered_set< _Kty, _Hasher, _Keyeq, _Alloc >::iterator

template<class _Kty, class _Hasher = hash<_Kty>, class _Keyeq = equal_to<_Kty>, class _Alloc = allocator<_Kty>>

typedef _Mytraits unordered_set< _Kty, _Hasher, _Keyeq, _Alloc >::key_compare

template<class _Kty, class _Hasher = hash<_Kty>, class _Keyeq = equal_to<_Kty>, class _Alloc = allocator<_Kty>>

typedef _Keyeq unordered_set< _Kty, _Hasher, _Keyeq, _Alloc >::key_equal

template<class _Kty, class _Hasher = hash<_Kty>, class _Keyeq = equal_to<_Kty>, class _Alloc = allocator<_Kty>>

typedef _Kty unordered_set< _Kty, _Hasher, _Keyeq, _Alloc >::key_type

template<class _Kty, class _Hasher = hash<_Kty>, class _Keyeq = equal_to<_Kty>, class _Alloc = allocator<_Kty>>

typedef _Mybase::iterator unordered_set< _Kty, _Hasher, _Keyeq, _Alloc >::local_iterator

template<class _Kty, class _Hasher = hash<_Kty>, class _Keyeq = equal_to<_Kty>, class _Alloc = allocator<_Kty>>

typedef _Mybase::pointer unordered_set< _Kty, _Hasher, _Keyeq, _Alloc >::pointer

template<class _Kty, class _Hasher = hash<_Kty>, class _Keyeq = equal_to<_Kty>, class _Alloc = allocator<_Kty>>

typedef _Mybase::reference unordered_set< _Kty, _Hasher, _Keyeq, _Alloc >::reference

template<class _Kty, class _Hasher = hash<_Kty>, class _Keyeq = equal_to<_Kty>, class _Alloc = allocator<_Kty>>

typedef _Mybase::size_type unordered_set< _Kty, _Hasher, _Keyeq, _Alloc >::size_type

template<class _Kty, class _Hasher = hash<_Kty>, class _Keyeq = equal_to<_Kty>, class _Alloc = allocator<_Kty>>

typedef _Mybase::value_type unordered_set< _Kty, _Hasher, _Keyeq, _Alloc >::value_type

Constructor & Destructor Documentation

template<class _Kty, class _Hasher = hash<_Kty>, class _Keyeq = equal_to<_Kty>, class _Alloc = allocator<_Kty>>

unordered_set< _Kty, _Hasher, _Keyeq, _Alloc >::unordered_set ( )

inline

         : _Mybase(key_compare(), allocator_type())
         {   // construct empty set from defaults
         }

template<class _Kty, class _Hasher = hash<_Kty>, class _Keyeq = equal_to<_Kty>, class _Alloc = allocator<_Kty>>

unordered_set< _Kty, _Hasher, _Keyeq, _Alloc >::unordered_set ( const allocator_type & _Al )

inlineexplicit

         : _Mybase(key_compare(), _Al)
         {   // construct empty set from defaults, allocator
         }

template<class _Kty, class _Hasher = hash<_Kty>, class _Keyeq = equal_to<_Kty>, class _Alloc = allocator<_Kty>>

unordered_set< _Kty, _Hasher, _Keyeq, _Alloc >::unordered_set ( const _Myt & _Right )

inline

         : _Mybase(_Right,
             _Right._List._Getal().select_on_container_copy_construction())
         {   // construct set by copying _Right
         }

template<class _Kty, class _Hasher = hash<_Kty>, class _Keyeq = equal_to<_Kty>, class _Alloc = allocator<_Kty>>

unordered_set< _Kty, _Hasher, _Keyeq, _Alloc >::unordered_set	(	const _Myt &	_Right,
		const allocator_type &	_Al
	)

inline

         : _Mybase(_Right, _Al)
         {   // construct set by copying _Right, allocator
         }

template<class _Kty, class _Hasher = hash<_Kty>, class _Keyeq = equal_to<_Kty>, class _Alloc = allocator<_Kty>>

unordered_set< _Kty, _Hasher, _Keyeq, _Alloc >::unordered_set ( size_type _Buckets )

inlineexplicit

         : _Mybase(key_compare(), allocator_type())
         {   // construct empty set from bucket count
         this->rehash(_Buckets);
         }

template<class _Kty, class _Hasher = hash<_Kty>, class _Keyeq = equal_to<_Kty>, class _Alloc = allocator<_Kty>>

unordered_set< _Kty, _Hasher, _Keyeq, _Alloc >::unordered_set	(	size_type	_Buckets,
		const allocator_type &	_Al
	)

inline

         : _Mybase(key_compare(), _Al)
         {   // construct empty set from bucket count and allocator
         this->rehash(_Buckets);
         }

template<class _Kty, class _Hasher = hash<_Kty>, class _Keyeq = equal_to<_Kty>, class _Alloc = allocator<_Kty>>

unordered_set< _Kty, _Hasher, _Keyeq, _Alloc >::unordered_set	(	size_type	_Buckets,
		const hasher &	_Hasharg
	)

inline

         : _Mybase(key_compare(_Hasharg), allocator_type())
         {   // construct empty set from bucket count and hasher
         this->rehash(_Buckets);
         }

template<class _Kty, class _Hasher = hash<_Kty>, class _Keyeq = equal_to<_Kty>, class _Alloc = allocator<_Kty>>

unordered_set< _Kty, _Hasher, _Keyeq, _Alloc >::unordered_set	(	size_type	_Buckets,
		const hasher &	_Hasharg,
		const allocator_type &	_Al
	)

inline

         : _Mybase(key_compare(_Hasharg), _Al)
         {   // construct empty set from bucket count, hasher, and allocator
         this->rehash(_Buckets);
         }

template<class _Kty, class _Hasher = hash<_Kty>, class _Keyeq = equal_to<_Kty>, class _Alloc = allocator<_Kty>>

unordered_set< _Kty, _Hasher, _Keyeq, _Alloc >::unordered_set	(	size_type	_Buckets,
		const hasher &	_Hasharg,
		const _Keyeq &	_Keyeqarg
	)

inline

         : _Mybase(key_compare(_Hasharg, _Keyeqarg), allocator_type())
         {   // construct empty set from bucket count, hasher, and equality comparator
         this->rehash(_Buckets);
         }

template<class _Kty, class _Hasher = hash<_Kty>, class _Keyeq = equal_to<_Kty>, class _Alloc = allocator<_Kty>>

unordered_set< _Kty, _Hasher, _Keyeq, _Alloc >::unordered_set	(	size_type	_Buckets,
		const hasher &	_Hasharg,
		const _Keyeq &	_Keyeqarg,
		const allocator_type &	_Al
	)

inline

         : _Mybase(key_compare(_Hasharg, _Keyeqarg), _Al)
         {   // construct empty set from bucket count, hasher, equality comparator, and allocator
         this->rehash(_Buckets);
         }

template<class _Kty, class _Hasher = hash<_Kty>, class _Keyeq = equal_to<_Kty>, class _Alloc = allocator<_Kty>>

template<class _Iter >

unordered_set< _Kty, _Hasher, _Keyeq, _Alloc >::unordered_set	(	_Iter	_First,
		_Iter	_Last
	)

inline

         : _Mybase(key_compare(), allocator_type())
         {   // construct set from sequence, defaults
         this->insert(_First, _Last);
         }

template<class _Kty, class _Hasher = hash<_Kty>, class _Keyeq = equal_to<_Kty>, class _Alloc = allocator<_Kty>>

template<class _Iter >

unordered_set< _Kty, _Hasher, _Keyeq, _Alloc >::unordered_set	(	_Iter	_First,
		_Iter	_Last,
		const allocator_type &	_Al
	)

inline

         : _Mybase(key_compare(), _Al)
         {   // construct set from sequence and allocator
         this->insert(_First, _Last);
         }

template<class _Kty, class _Hasher = hash<_Kty>, class _Keyeq = equal_to<_Kty>, class _Alloc = allocator<_Kty>>

template<class _Iter >

unordered_set< _Kty, _Hasher, _Keyeq, _Alloc >::unordered_set	(	_Iter	_First,
		_Iter	_Last,
		size_type	_Buckets
	)

inline

         : _Mybase(key_compare(), allocator_type())
         {   // construct set from sequence and bucket count
         this->rehash(_Buckets);
         this->insert(_First, _Last);
         }

template<class _Kty, class _Hasher = hash<_Kty>, class _Keyeq = equal_to<_Kty>, class _Alloc = allocator<_Kty>>

template<class _Iter >

unordered_set< _Kty, _Hasher, _Keyeq, _Alloc >::unordered_set	(	_Iter	_First,
		_Iter	_Last,
		size_type	_Buckets,
		const allocator_type &	_Al
	)

inline

         : _Mybase(key_compare(), _Al)
         {   // construct set from sequence, bucket count, and allocator
         this->rehash(_Buckets);
         this->insert(_First, _Last);
         }

template<class _Kty, class _Hasher = hash<_Kty>, class _Keyeq = equal_to<_Kty>, class _Alloc = allocator<_Kty>>

template<class _Iter >

unordered_set< _Kty, _Hasher, _Keyeq, _Alloc >::unordered_set	(	_Iter	_First,
		_Iter	_Last,
		size_type	_Buckets,
		const hasher &	_Hasharg
	)

inline

         : _Mybase(key_compare(_Hasharg), allocator_type())
         {   // construct set from sequence, bucket count, and hasher
         this->rehash(_Buckets);
         this->insert(_First, _Last);
         }

template<class _Kty, class _Hasher = hash<_Kty>, class _Keyeq = equal_to<_Kty>, class _Alloc = allocator<_Kty>>

template<class _Iter >

unordered_set< _Kty, _Hasher, _Keyeq, _Alloc >::unordered_set	(	_Iter	_First,
		_Iter	_Last,
		size_type	_Buckets,
		const hasher &	_Hasharg,
		const allocator_type &	_Al
	)

inline

         : _Mybase(key_compare(_Hasharg), _Al)
         {   // construct set from sequence, bucket count, hasher, and allocator
         this->rehash(_Buckets);
         this->insert(_First, _Last);
         }

template<class _Kty, class _Hasher = hash<_Kty>, class _Keyeq = equal_to<_Kty>, class _Alloc = allocator<_Kty>>

template<class _Iter >

unordered_set< _Kty, _Hasher, _Keyeq, _Alloc >::unordered_set	(	_Iter	_First,
		_Iter	_Last,
		size_type	_Buckets,
		const hasher &	_Hasharg,
		const _Keyeq &	_Keyeqarg
	)

inline

         : _Mybase(key_compare(_Hasharg, _Keyeqarg), allocator_type())
         {   // construct set from sequence, bucket count, hasher, and equality comparator
         this->rehash(_Buckets);
         this->insert(_First, _Last);
         }

template<class _Kty, class _Hasher = hash<_Kty>, class _Keyeq = equal_to<_Kty>, class _Alloc = allocator<_Kty>>

template<class _Iter >

unordered_set< _Kty, _Hasher, _Keyeq, _Alloc >::unordered_set	(	_Iter	_First,
		_Iter	_Last,
		size_type	_Buckets,
		const hasher &	_Hasharg,
		const _Keyeq &	_Keyeqarg,
		const allocator_type &	_Al
	)

inline

         : _Mybase(key_compare(_Hasharg, _Keyeqarg), _Al)
         {   // construct set from sequence, bucket count, hasher, equality comparator, and allocator
         this->rehash(_Buckets);
         this->insert(_First, _Last);
         }

template<class _Kty, class _Hasher = hash<_Kty>, class _Keyeq = equal_to<_Kty>, class _Alloc = allocator<_Kty>>

unordered_set< _Kty, _Hasher, _Keyeq, _Alloc >::unordered_set ( _Myt && _Right )

inline

         : _Mybase(_STD move(_Right))
         {   // construct set by moving _Right
         }

template<class _Kty, class _Hasher = hash<_Kty>, class _Keyeq = equal_to<_Kty>, class _Alloc = allocator<_Kty>>

unordered_set< _Kty, _Hasher, _Keyeq, _Alloc >::unordered_set	(	_Myt &&	_Right,
		const allocator_type &	_Al
	)

inline

         : _Mybase(_STD move(_Right), _Al)
         {   // construct set by moving _Right, allocator
         }

template<class _Kty, class _Hasher = hash<_Kty>, class _Keyeq = equal_to<_Kty>, class _Alloc = allocator<_Kty>>

unordered_set< _Kty, _Hasher, _Keyeq, _Alloc >::unordered_set ( initializer_list< value_type > _Ilist )

inline

         : _Mybase(key_compare(), allocator_type())
         {   // construct set from initializer_list, defaults
         this->insert(_Ilist);
         }

template<class _Kty, class _Hasher = hash<_Kty>, class _Keyeq = equal_to<_Kty>, class _Alloc = allocator<_Kty>>

unordered_set< _Kty, _Hasher, _Keyeq, _Alloc >::unordered_set	(	initializer_list< value_type >	_Ilist,
		const allocator_type &	_Al
	)

inline

         : _Mybase(key_compare(), _Al)
         {   // construct set from initializer_list and allocator
         this->insert(_Ilist);
         }

template<class _Kty, class _Hasher = hash<_Kty>, class _Keyeq = equal_to<_Kty>, class _Alloc = allocator<_Kty>>

unordered_set< _Kty, _Hasher, _Keyeq, _Alloc >::unordered_set	(	initializer_list< value_type >	_Ilist,
		size_type	_Buckets
	)

inline

         : _Mybase(key_compare(), allocator_type())
         {   // construct set from initializer_list and bucket count
         this->rehash(_Buckets);
         this->insert(_Ilist);
         }

template<class _Kty, class _Hasher = hash<_Kty>, class _Keyeq = equal_to<_Kty>, class _Alloc = allocator<_Kty>>

unordered_set< _Kty, _Hasher, _Keyeq, _Alloc >::unordered_set	(	initializer_list< value_type >	_Ilist,
		size_type	_Buckets,
		const allocator_type &	_Al
	)

inline

         : _Mybase(key_compare(), _Al)
         {   // construct set from initializer_list, bucket count, and allocator
         this->rehash(_Buckets);
         this->insert(_Ilist);
         }

template<class _Kty, class _Hasher = hash<_Kty>, class _Keyeq = equal_to<_Kty>, class _Alloc = allocator<_Kty>>

unordered_set< _Kty, _Hasher, _Keyeq, _Alloc >::unordered_set	(	initializer_list< value_type >	_Ilist,
		size_type	_Buckets,
		const hasher &	_Hasharg
	)

inline

         : _Mybase(key_compare(_Hasharg), allocator_type())
         {   // construct set from initializer_list, bucket count, and hasher
         this->rehash(_Buckets);
         this->insert(_Ilist);
         }

template<class _Kty, class _Hasher = hash<_Kty>, class _Keyeq = equal_to<_Kty>, class _Alloc = allocator<_Kty>>

unordered_set< _Kty, _Hasher, _Keyeq, _Alloc >::unordered_set	(	initializer_list< value_type >	_Ilist,
		size_type	_Buckets,
		const hasher &	_Hasharg,
		const allocator_type &	_Al
	)

inline

         : _Mybase(key_compare(_Hasharg), _Al)
         {   // construct set from initializer_list, bucket count, hasher, and allocator
         this->rehash(_Buckets);
         this->insert(_Ilist);
         }

template<class _Kty, class _Hasher = hash<_Kty>, class _Keyeq = equal_to<_Kty>, class _Alloc = allocator<_Kty>>

unordered_set< _Kty, _Hasher, _Keyeq, _Alloc >::unordered_set	(	initializer_list< value_type >	_Ilist,
		size_type	_Buckets,
		const hasher &	_Hasharg,
		const _Keyeq &	_Keyeqarg
	)

inline

         : _Mybase(key_compare(_Hasharg, _Keyeqarg), allocator_type())
         {   // construct set from initializer_list, bucket count, hasher, and equality comparator
         this->rehash(_Buckets);
         this->insert(_Ilist);
         }

template<class _Kty, class _Hasher = hash<_Kty>, class _Keyeq = equal_to<_Kty>, class _Alloc = allocator<_Kty>>

unordered_set< _Kty, _Hasher, _Keyeq, _Alloc >::unordered_set	(	initializer_list< value_type >	_Ilist,
		size_type	_Buckets,
		const hasher &	_Hasharg,
		const _Keyeq &	_Keyeqarg,
		const allocator_type &	_Al
	)

inline

         : _Mybase(key_compare(_Hasharg, _Keyeqarg), _Al)
         {   // construct from initializer_list, bucket count, hasher, equality comparator, and allocator
         this->rehash(_Buckets);
         this->insert(_Ilist);
         }

Member Function Documentation

template<class _Kty, class _Hasher = hash<_Kty>, class _Keyeq = equal_to<_Kty>, class _Alloc = allocator<_Kty>>

hasher unordered_set< _Kty, _Hasher, _Keyeq, _Alloc >::hash_function ( ) const

inline

         {   // return hasher object
         return (this->_Traitsobj._Gethash());
         }

template<class _Kty, class _Hasher = hash<_Kty>, class _Keyeq = equal_to<_Kty>, class _Alloc = allocator<_Kty>>

key_equal unordered_set< _Kty, _Hasher, _Keyeq, _Alloc >::key_eq ( ) const

inline

         {   // return equality comparator object
         return (this->_Traitsobj._Getkeyeq());
         }

template<class _Kty, class _Hasher = hash<_Kty>, class _Keyeq = equal_to<_Kty>, class _Alloc = allocator<_Kty>>

_Myt& unordered_set< _Kty, _Hasher, _Keyeq, _Alloc >::operator= ( const _Myt & _Right )

inline

         {   // assign by copying _Right
         _Mybase::operator=(_Right);
         return (*this);
         }

template<class _Kty, class _Hasher = hash<_Kty>, class _Keyeq = equal_to<_Kty>, class _Alloc = allocator<_Kty>>

_Myt& unordered_set< _Kty, _Hasher, _Keyeq, _Alloc >::operator= ( _Myt && _Right )

inline

         {   // assign by moving _Right
         _Mybase::operator=(_STD move(_Right));
         return (*this);
         }

template<class _Kty, class _Hasher = hash<_Kty>, class _Keyeq = equal_to<_Kty>, class _Alloc = allocator<_Kty>>

_Myt& unordered_set< _Kty, _Hasher, _Keyeq, _Alloc >::operator= ( initializer_list< value_type > _Ilist )

inline

         {   // assign initializer_list
         this->clear();
         this->insert(_Ilist);
         return (*this);
         }

template<class _Kty, class _Hasher = hash<_Kty>, class _Keyeq = equal_to<_Kty>, class _Alloc = allocator<_Kty>>

void unordered_set< _Kty, _Hasher, _Keyeq, _Alloc >::swap ( _Myt & _Right )

inline

         {   // exchange contents with non-movable _Right
         _Mybase::swap(_Right);
         }

The documentation for this class was generated from the following file:

VS2017/inc/unordered_set