unordered_map< _Kty, _Ty, _Hasher, _Keyeq, _Alloc > Class Template Reference

Inheritance diagram for unordered_map< _Kty, _Ty, _Hasher, _Keyeq, _Alloc >:

Public Types
typedef unordered_map< _Kty, _Ty, _Hasher, _Keyeq, _Alloc >	_Myt
typedef _Uhash_compare< _Kty, _Hasher, _Keyeq >	_Mytraits
typedef _Hash< _Umap_traits< _Kty, _Ty, _Mytraits, _Alloc, false > >	_Mybase
typedef _Hasher	hasher
typedef _Kty	key_type
typedef _Ty	mapped_type
typedef _Ty	referent_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
Public Types inherited from _Hash< _Umap_traits< _Kty, _Ty, _Uhash_compare< _Kty, _Hasher, _Keyeq >, _Alloc, false > >
enum
typedef _Hash< _Umap_traits< _Kty, _Ty, _Uhash_compare< _Kty, _Hasher, _Keyeq >, _Alloc, false > >	_Myt
typedef _Umap_traits< _Kty, _Ty, _Uhash_compare< _Kty, _Hasher, _Keyeq >, _Alloc, false >::key_type	key_type
typedef _Umap_traits< _Kty, _Ty, _Uhash_compare< _Kty, _Hasher, _Keyeq >, _Alloc, false >::key_compare	key_compare
typedef _Umap_traits< _Kty, _Ty, _Uhash_compare< _Kty, _Hasher, _Keyeq >, _Alloc, false >::value_compare	value_compare
typedef list< typename _Umap_traits< _Kty, _Ty, _Uhash_compare< _Kty, _Hasher, _Keyeq >, _Alloc, false >::value_type, typename _Umap_traits< _Kty, _Ty, _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 _STD reverse_iterator< iterator >	reverse_iterator
typedef _STD reverse_iterator< const_iterator >	const_reverse_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 Types inherited from _Umap_traits< _Kty, _Ty, _Uhash_compare< _Kty, _Hasher, _Keyeq >, _Alloc, false >
enum
typedef _Kty	key_type
typedef pair< const _Kty, _Ty >	value_type
typedef _Uhash_compare< _Kty, _Hasher, _Keyeq >	key_compare
typedef _Alloc	allocator_type
Public Types inherited from _Uhash_compare< _Kty, _Hasher, _Keyeq >
enum	{ bucket_size = 1 }
typedef _Hash_oper2<!is_empty< _Keyeq >::value, _Hasher, _Keyeq >	_Mybase
Public Types inherited from _Hash_oper2<!is_empty< _Keyeq >::value, _Hasher, _Keyeq >
typedef _Hash_oper1<!is_empty< _Hasher >::value, _Hasher >	_Mybase
Public Types inherited from _Hash_oper1<!is_empty< _Hasher >::value, _Hasher >
typedef _Hasher	hasher

Public Member Functions
	unordered_map ()
	unordered_map (const allocator_type &_Al)
	unordered_map (const _Myt &_Right)
	unordered_map (const _Myt &_Right, const allocator_type &_Al)
	unordered_map (size_type _Buckets)
	unordered_map (size_type _Buckets, const hasher &_Hasharg)
	unordered_map (size_type _Buckets, const hasher &_Hasharg, const _Keyeq &_Keyeqarg)
	unordered_map (size_type _Buckets, const hasher &_Hasharg, const _Keyeq &_Keyeqarg, const allocator_type &_Al)
template<class _Iter >
	unordered_map (_Iter _First, _Iter _Last)
template<class _Iter >
	unordered_map (_Iter _First, _Iter _Last, size_type _Buckets)
template<class _Iter >
	unordered_map (_Iter _First, _Iter _Last, size_type _Buckets, const hasher &_Hasharg)
template<class _Iter >
	unordered_map (_Iter _First, _Iter _Last, size_type _Buckets, const hasher &_Hasharg, const _Keyeq &_Keyeqarg)
template<class _Iter >
	unordered_map (_Iter _First, _Iter _Last, size_type _Buckets, const hasher &_Hasharg, const _Keyeq &_Keyeqarg, const allocator_type &_Al)
_Myt &	operator= (const _Myt &_Right)
	unordered_map (_Myt &&_Right)
	unordered_map (_Myt &&_Right, const allocator_type &_Al)
_Myt &	operator= (_Myt &&_Right)
mapped_type &	operator[] (key_type &&_Keyval)
void	swap (_Myt &_Right)
	unordered_map (_XSTD initializer_list< value_type > _Ilist)
	unordered_map (_XSTD initializer_list< value_type > _Ilist, size_type _Buckets)
	unordered_map (_XSTD initializer_list< value_type > _Ilist, size_type _Buckets, const hasher &_Hasharg)
	unordered_map (_XSTD initializer_list< value_type > _Ilist, size_type _Buckets, const hasher &_Hasharg, const _Keyeq &_Keyeqarg)
	unordered_map (_XSTD initializer_list< value_type > _Ilist, size_type _Buckets, const hasher &_Hasharg, const _Keyeq &_Keyeqarg, const allocator_type &_Al)
_Myt &	operator= (_XSTD initializer_list< value_type > _Ilist)
hasher	hash_function () const
key_equal	key_eq () const
mapped_type &	operator[] (const key_type &_Keyval)
mapped_type &	at (const key_type &_Keyval)
const mapped_type &	at (const key_type &_Keyval) const
Public Member Functions inherited from _Hash< _Umap_traits< _Kty, _Ty, _Uhash_compare< _Kty, _Hasher, _Keyeq >, _Alloc, false > >
	_Hash (const key_compare &_Parg, const allocator_type &_Al)
	_Hash (const value_type *_First, const value_type *_Last, const key_compare &_Parg, const allocator_type &_Al)
	_Hash (const _Myt &_Right, const allocator_type &_Al)
	_Hash (_Myt &&_Right, const allocator_type &_Al)
_Myt &	operator= (_Myt &&_Right)
_Myt &	operator= (const _Myt &_Right)
void	_Assign_rv (_Myt &&_Right)
_Pairib	insert (value_type &&_Val)
iterator	insert (const_iterator, value_type &&_Val)
enable_if< is_convertible< _Valty, value_type >::value, _Pairib >::type	insert (_Valty &&_Val)
enable_if< is_convertible< _Valty, value_type >::value, iterator >::type	insert (const_iterator, _Valty &&_Val)
_Pairib	insert (const value_type &_Val)
iterator	insert (const_iterator, const value_type &_Val)
void	insert (_Iter _First, _Iter _Last)
void	insert (_XSTD initializer_list< value_type > _Ilist)
_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
reverse_iterator	rbegin () _NOEXCEPT
const_reverse_iterator	rbegin () const _NOEXCEPT
reverse_iterator	rend () _NOEXCEPT
const_reverse_iterator	rend () const _NOEXCEPT
const_iterator	cbegin () const _NOEXCEPT
const_local_iterator	cbegin (size_type _Bucket) const _NOEXCEPT
const_iterator	cend () const _NOEXCEPT
const_local_iterator	cend (size_type _Bucket) const _NOEXCEPT
const_reverse_iterator	crbegin () const _NOEXCEPT
const_reverse_iterator	crend () const _NOEXCEPT
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)
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)
Public Member Functions inherited from _Umap_traits< _Kty, _Ty, _Uhash_compare< _Kty, _Hasher, _Keyeq >, _Alloc, false >
	_Umap_traits (const _Uhash_compare< _Kty, _Hasher, _Keyeq > &_Traits=_Uhash_compare< _Kty, _Hasher, _Keyeq >())
Public Member Functions inherited from _Uhash_compare< _Kty, _Hasher, _Keyeq >
	_Uhash_compare (_Hasher _Hasharg=_Hasher(), _Keyeq _Keyeqarg=_Keyeq())
	_Uhash_compare (_Keyeq _Keyeqarg)
size_t	operator() (const _Kty &_Keyval) const
bool	operator() (const _Kty &_Keyval1, const _Kty &_Keyval2) const
Public Member Functions inherited from _Hash_oper2<!is_empty< _Keyeq >::value, _Hasher, _Keyeq >
	_Hash_oper2 (_Hasher _Hasharg=_Hasher(), _Keyeq _Keyeqarg=_Keyeq())
const _Keyeq &	_Getkeyeq () const
Public Member Functions inherited from _Hash_oper1<!is_empty< _Hasher >::value, _Hasher >
	_Hash_oper1 (_Hasher _Hasharg)
const hasher &	_Gethash () const

Additional Inherited Members
Static Public Member Functions inherited from _Umap_traits< _Kty, _Ty, _Uhash_compare< _Kty, _Hasher, _Keyeq >, _Alloc, false >
static const _Kty &	_Kfn (const pair< _Ty1, _Ty2 > &_Val)
static const _Ty2 &	_Nonkfn (const pair< _Ty1, _Ty2 > &_Val)
Public Attributes inherited from _Hash_oper2<!is_empty< _Keyeq >::value, _Hasher, _Keyeq >
_Keyeq	_Keyeqobj
Public Attributes inherited from _Hash_oper1<!is_empty< _Hasher >::value, _Hasher >
_Hasher	_Hashobj
Protected Member Functions inherited from _Hash< _Umap_traits< _Kty, _Ty, _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 ()
Protected Attributes inherited from _Hash< _Umap_traits< _Kty, _Ty, _Uhash_compare< _Kty, _Hasher, _Keyeq >, _Alloc, false > >
_Mylist	_List
_Myvec	_Vec
size_type	_Mask
size_type	_Maxidx
float	_Max_bucket_size

Member Typedef Documentation

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

typedef _Hash<_Umap_traits<_Kty, _Ty, _Mytraits, _Alloc, false> > unordered_map< _Kty, _Ty, _Hasher, _Keyeq, _Alloc >::_Mybase

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

typedef unordered_map<_Kty, _Ty, _Hasher, _Keyeq, _Alloc> unordered_map< _Kty, _Ty, _Hasher, _Keyeq, _Alloc >::_Myt

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

typedef _Uhash_compare<_Kty, _Hasher, _Keyeq> unordered_map< _Kty, _Ty, _Hasher, _Keyeq, _Alloc >::_Mytraits

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

typedef _Mybase::allocator_type unordered_map< _Kty, _Ty, _Hasher, _Keyeq, _Alloc >::allocator_type

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

typedef _Mybase::const_iterator unordered_map< _Kty, _Ty, _Hasher, _Keyeq, _Alloc >::const_iterator

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

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

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

typedef _Mybase::const_pointer unordered_map< _Kty, _Ty, _Hasher, _Keyeq, _Alloc >::const_pointer

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

typedef _Mybase::const_reference unordered_map< _Kty, _Ty, _Hasher, _Keyeq, _Alloc >::const_reference

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

typedef _Mybase::difference_type unordered_map< _Kty, _Ty, _Hasher, _Keyeq, _Alloc >::difference_type

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

typedef _Hasher unordered_map< _Kty, _Ty, _Hasher, _Keyeq, _Alloc >::hasher

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

typedef _Mybase::iterator unordered_map< _Kty, _Ty, _Hasher, _Keyeq, _Alloc >::iterator

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

typedef _Mytraits unordered_map< _Kty, _Ty, _Hasher, _Keyeq, _Alloc >::key_compare

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

typedef _Keyeq unordered_map< _Kty, _Ty, _Hasher, _Keyeq, _Alloc >::key_equal

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

typedef _Kty unordered_map< _Kty, _Ty, _Hasher, _Keyeq, _Alloc >::key_type

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

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

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

typedef _Ty unordered_map< _Kty, _Ty, _Hasher, _Keyeq, _Alloc >::mapped_type

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

typedef _Mybase::pointer unordered_map< _Kty, _Ty, _Hasher, _Keyeq, _Alloc >::pointer

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

typedef _Mybase::reference unordered_map< _Kty, _Ty, _Hasher, _Keyeq, _Alloc >::reference

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

typedef _Ty unordered_map< _Kty, _Ty, _Hasher, _Keyeq, _Alloc >::referent_type

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

typedef _Mybase::size_type unordered_map< _Kty, _Ty, _Hasher, _Keyeq, _Alloc >::size_type

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

typedef _Mybase::value_type unordered_map< _Kty, _Ty, _Hasher, _Keyeq, _Alloc >::value_type

Constructor & Destructor Documentation

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

unordered_map< _Kty, _Ty, _Hasher, _Keyeq, _Alloc >::unordered_map ( )

inline

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

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

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

inlineexplicit

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

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

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

inline

        : _Mybase(_Right,
            _Right._List._Getal().select_on_container_copy_construction())


        {   // construct map by copying _Right
        }

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

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

inline

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

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

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

inlineexplicit

        : _Mybase(key_compare(), allocator_type())
        {   // construct empty map from defaults, ignore initial size
        this->rehash(_Buckets);
        }

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

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

inline

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

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

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

inline

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

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

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

inline

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

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

template<class _Iter >

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

inline

        : _Mybase(key_compare(), allocator_type())
        {   // construct map from sequence, defaults
        _Mybase::insert(_First, _Last);
        }

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

template<class _Iter >

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

inline

        : _Mybase(key_compare(), allocator_type())
        {   // construct map from sequence, ignore initial size
        this->rehash(_Buckets);
        _Mybase::insert(_First, _Last);
        }

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

template<class _Iter >

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

inline

        : _Mybase(key_compare(_Hasharg), allocator_type())
        {   // construct map from sequence, comparator
        this->rehash(_Buckets);
        _Mybase::insert(_First, _Last);
        }

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

template<class _Iter >

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

inline

        : _Mybase(key_compare(_Hasharg, _Keyeqarg), allocator_type())
        {   // construct map from sequence, comparator, and allocator
        this->rehash(_Buckets);
        _Mybase::insert(_First, _Last);
        }

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

template<class _Iter >

unordered_map< _Kty, _Ty, _Hasher, _Keyeq, _Alloc >::unordered_map ( _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 map from sequence, comparator, and allocator
        this->rehash(_Buckets);
        _Mybase::insert(_First, _Last);
        }

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

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

inline

        : _Mybase(_STD move(_Right), _Right._List._Getal())
        {   // construct map by moving _Right
        }

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

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

inline

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

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

unordered_map< _Kty, _Ty, _Hasher, _Keyeq, _Alloc >::unordered_map ( _XSTD initializer_list< value_type >  _Ilist )

inline

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

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

unordered_map< _Kty, _Ty, _Hasher, _Keyeq, _Alloc >::unordered_map ( _XSTD initializer_list< value_type >  _Ilist, size_type  _Buckets  )

inline

        : _Mybase(key_compare(), allocator_type())
        {   // construct map from initializer_list
        this->rehash(_Buckets);
        this->insert(_Ilist.begin(), _Ilist.end());
        }

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

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

inline

        : _Mybase(key_compare(_Hasharg), allocator_type())
        {   // construct map from initializer_list, hasher
        this->rehash(_Buckets);
        this->insert(_Ilist.begin(), _Ilist.end());
        }

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

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

inline

        : _Mybase(key_compare(_Hasharg, _Keyeqarg), allocator_type())
        {   // construct map from initializer_list, comparator
        this->rehash(_Buckets);
        this->insert(_Ilist.begin(), _Ilist.end());
        }

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

unordered_map< _Kty, _Ty, _Hasher, _Keyeq, _Alloc >::unordered_map ( _XSTD 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 map from initializer_list, allocator
        this->rehash(_Buckets);
        this->insert(_Ilist.begin(), _Ilist.end());
        }

Member Function Documentation

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

mapped_type& unordered_map< _Kty, _Ty, _Hasher, _Keyeq, _Alloc >::at ( const key_type &  _Keyval )

inline

        {   // find element matching _Keyval
        iterator _Where = this->lower_bound(_Keyval);
        if (_Where == this->end())
            _Xout_of_range("invalid unordered_map<K, T> key");
        return (_Where->second);
        }

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

const mapped_type& unordered_map< _Kty, _Ty, _Hasher, _Keyeq, _Alloc >::at ( const key_type &  _Keyval ) const

inline

        {   // find element matching _Keyval
        const_iterator _Where = this->lower_bound(_Keyval);
        if (_Where == this->end())
            _Xout_of_range("invalid unordered_map<K, T> key");
        return (_Where->second);
        }

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

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

inline

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

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

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

inline

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

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

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

inline

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

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

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

inline

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

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

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

inline

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

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

mapped_type& unordered_map< _Kty, _Ty, _Hasher, _Keyeq, _Alloc >::operator[] ( key_type &&  _Keyval )

inline

        {   // find element matching _Keyval or insert with default mapped
        iterator _Where = this->lower_bound(_Keyval);
        if (_Where == this->end())
            _Where = this->emplace(
                piecewise_construct,
                _STD forward_as_tuple(_STD move(_Keyval)),
                tuple<>()).first;
        return (_Where->second);
        }

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

mapped_type& unordered_map< _Kty, _Ty, _Hasher, _Keyeq, _Alloc >::operator[] ( const key_type &  _Keyval )

inline

        {   // find element matching _Keyval or insert with default mapped
        iterator _Where = this->lower_bound(_Keyval);
        if (_Where == this->end())

            _Where = this->emplace(
                piecewise_construct,
                _STD forward_as_tuple(_Keyval),
                tuple<>()).first;

        return (_Where->second);
        }

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

void unordered_map< _Kty, _Ty, _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:

• VS2013/inc/unordered_map