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

STLdoc

STLdocumentation

All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros

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 _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

typedef _Mybase::_Pairib	_Pairib

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 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_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 allocator_type &_Al)

	unordered_map (size_type _Buckets, const hasher &_Hasharg)

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

	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, const allocator_type &_Al)

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 allocator_type &_Al)

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 allocator_type &_Al)

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) _NOEXCEPT_OP(_Alty

mapped_type &	operator[] (key_type &&_Keyval)

void	swap (_Myt &_Right) _NOEXCEPT_OP(_Alty

template<class _Valty , class = enable_if_t<is_constructible<value_type, _Valty>::value>>
_Pairib	insert (_Valty &&_Val)

template<class _Valty , class = enable_if_t<is_constructible<value_type, _Valty>::value>>
iterator	insert (const_iterator _Where, _Valty &&_Val)

template<class _Keyty , class... _Mappedty>
_Pairib	_Try_emplace (_Keyty &&_Keyval, _Mappedty &&..._Mapval)

template<class... _Mappedty>
_Pairib	try_emplace (const key_type &_Keyval, _Mappedty &&..._Mapval)

template<class... _Mappedty>
iterator	try_emplace (const_iterator, const key_type &_Keyval, _Mappedty &&..._Mapval)

template<class... _Mappedty>
_Pairib	try_emplace (key_type &&_Keyval, _Mappedty &&..._Mapval)

template<class... _Mappedty>
iterator	try_emplace (const_iterator, key_type &&_Keyval, _Mappedty &&..._Mapval)

template<class _Keyty , class _Mappedty >
_Pairib	_Insert_or_assign (_Keyty &&_Keyval, _Mappedty &&_Mapval)

template<class _Mappedty >
_Pairib	insert_or_assign (const key_type &_Keyval, _Mappedty &&_Mapval)

template<class _Mappedty >
iterator	insert_or_assign (const_iterator, const key_type &_Keyval, _Mappedty &&_Mapval)

template<class _Mappedty >
_Pairib	insert_or_assign (key_type &&_Keyval, _Mappedty &&_Mapval)

template<class _Mappedty >
iterator	insert_or_assign (const_iterator, key_type &&_Keyval, _Mappedty &&_Mapval)

	unordered_map (initializer_list< value_type > _Ilist)

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

	unordered_map (initializer_list< value_type > _Ilist, size_type _Buckets)

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

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

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

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

	unordered_map (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

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 _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< _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 ()

float &	_Max_bucket_size () _NOEXCEPT

const float &	_Max_bucket_size () const _NOEXCEPT

Protected Attributes inherited from _Hash< _Umap_traits< _Kty, _Ty, _Uhash_compare< _Kty, _Hasher, _Keyeq >, _Alloc, false > >
_Umap_traits< _Kty, _Ty, _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 _Ty, class _Hasher = hash<_Kty>, class _Keyeq = equal_to<_Kty>, class _Alloc = allocator<pair<const _Kty, _Ty> >>

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

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::_Pairib unordered_map< _Kty, _Ty, _Hasher, _Keyeq, _Alloc >::_Pairib

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 _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 bucket count
         _Mybase::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 allocator_type &	_Al
	)

inline

         : _Mybase(key_compare(), _Al)
         {   // construct empty map from bucket count and allocator
         _Mybase::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 bucket count and hasher
         _Mybase::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 allocator_type &	_Al
	)

inline

         : _Mybase(key_compare(_Hasharg), _Al)
         {   // construct empty map from bucket count, hasher, and allocator
         _Mybase::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 bucket count, hasher, and equality comparator
         _Mybase::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 bucket count, hasher, equality comparator, and allocator
         _Mybase::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
         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,
		const allocator_type &	_Al
	)

inline

         : _Mybase(key_compare(), _Al)
         {   // construct map from sequence and allocator
         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 and bucket count
         _Mybase::rehash(_Buckets);
         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 allocator_type &	_Al
	)

inline

         : _Mybase(key_compare(), _Al)
         {   // construct map from sequence, bucket count, and allocator
         _Mybase::rehash(_Buckets);
         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, bucket count, and hasher
         _Mybase::rehash(_Buckets);
         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 allocator_type &	_Al
	)

inline

         : _Mybase(key_compare(_Hasharg), _Al)
         {   // construct map from sequence, bucket count, hasher, and allocator
         _Mybase::rehash(_Buckets);
         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, bucket count, hasher, and equality comparator
         _Mybase::rehash(_Buckets);
         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, bucket count, hasher, equality comparator, and allocator
         _Mybase::rehash(_Buckets);
         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))
         {   // 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 ( initializer_list< value_type > _Ilist )

inline

         : _Mybase(key_compare(), allocator_type())
         {   // construct map from initializer_list, defaults
         insert(_Ilist);
         }

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	(	initializer_list< value_type >	_Ilist,
		const allocator_type &	_Al
	)

inline

         : _Mybase(key_compare(), _Al)
         {   // construct map from initializer_list and allocator
         insert(_Ilist);
         }

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	(	initializer_list< value_type >	_Ilist,
		size_type	_Buckets
	)

inline

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

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	(	initializer_list< value_type >	_Ilist,
		size_type	_Buckets,
		const allocator_type &	_Al
	)

inline

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

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	(	initializer_list< value_type >	_Ilist,
		size_type	_Buckets,
		const hasher &	_Hasharg
	)

inline

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

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	(	initializer_list< value_type >	_Ilist,
		size_type	_Buckets,
		const hasher &	_Hasharg,
		const allocator_type &	_Al
	)

inline

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

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	(	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, bucket count, hasher, and equality comparator
         _Mybase::rehash(_Buckets);
         insert(_Ilist);
         }

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	(	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, bucket count, hasher, equality comparator, and allocator
         _Mybase::rehash(_Buckets);
         insert(_Ilist);
         }

Member Function Documentation

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

template<class _Keyty , class _Mappedty >

_Pairib unordered_map< _Kty, _Ty, _Hasher, _Keyeq, _Alloc >::_Insert_or_assign	(	_Keyty &&	_Keyval,
		_Mappedty &&	_Mapval
	)

inline

         {   // assign if _Keyval present, else insert
         iterator _Where = _Mybase::find(_Keyval);
         if (_Where == _Mybase::end())
             return (_Mybase::emplace(
                 _STD forward<_Keyty>(_Keyval),
                 _STD forward<_Mappedty>(_Mapval)));
         else
             {   // _Keyval present, assign new value
             _Where->second = _STD forward<_Mappedty>(_Mapval);
             return (_Pairib(_Where, false));
             }
         }

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

template<class _Keyty , class... _Mappedty>

_Pairib unordered_map< _Kty, _Ty, _Hasher, _Keyeq, _Alloc >::_Try_emplace	(	_Keyty &&	_Keyval,
		_Mappedty &&...	_Mapval
	)

inline

         {   // fail if _Keyval present, else emplace
         iterator _Where = _Mybase::find(_Keyval);
         if (_Where == _Mybase::end())
             return (_Mybase::emplace(
                 piecewise_construct,
                 _STD forward_as_tuple(_STD forward<_Keyty>(_Keyval)),
                 _STD forward_as_tuple(_STD forward<_Mappedty>(_Mapval)...)));
         else
             return (_Pairib(_Where, false));
         }

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 = _Mybase::lower_bound(_Keyval);
         if (_Where == _Mybase::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 = _Mybase::lower_bound(_Keyval);
         if (_Where == _Mybase::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 (_Mybase::_Traitsobj._Gethash());
         }

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

template<class _Valty , class = enable_if_t<is_constructible<value_type, _Valty>::value>>

_Pairib unordered_map< _Kty, _Ty, _Hasher, _Keyeq, _Alloc >::insert ( _Valty && _Val )

inline

         {   // insert _Val
         return (this->emplace(_STD forward<_Valty>(_Val)));
         }

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

template<class _Valty , class = enable_if_t<is_constructible<value_type, _Valty>::value>>

iterator unordered_map< _Kty, _Ty, _Hasher, _Keyeq, _Alloc >::insert	(	const_iterator	_Where,
		_Valty &&	_Val
	)

inline

         {   // insert _Val with hint
         return (this->emplace_hint(_Where, _STD forward<_Valty>(_Val)));
         }

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

template<class _Mappedty >

_Pairib unordered_map< _Kty, _Ty, _Hasher, _Keyeq, _Alloc >::insert_or_assign	(	const key_type &	_Keyval,
		_Mappedty &&	_Mapval
	)

inline

         {   // assign if _Keyval present, else insert
         return (_Insert_or_assign(_Keyval,
             _STD forward<_Mappedty>(_Mapval)));
         }

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

template<class _Mappedty >

iterator unordered_map< _Kty, _Ty, _Hasher, _Keyeq, _Alloc >::insert_or_assign	(	const_iterator	,
		const key_type &	_Keyval,
		_Mappedty &&	_Mapval
	)

inline

         {   // assign if _Keyval present, else insert, ignore hint
         return (_Insert_or_assign(_Keyval,
             _STD forward<_Mappedty>(_Mapval)).first);
         }

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

template<class _Mappedty >

_Pairib unordered_map< _Kty, _Ty, _Hasher, _Keyeq, _Alloc >::insert_or_assign	(	key_type &&	_Keyval,
		_Mappedty &&	_Mapval
	)

inline

         {   // assign if _Keyval present, else insert
         return (_Insert_or_assign(_STD move(_Keyval),
             _STD forward<_Mappedty>(_Mapval)));
         }

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

template<class _Mappedty >

iterator unordered_map< _Kty, _Ty, _Hasher, _Keyeq, _Alloc >::insert_or_assign	(	const_iterator	,
		key_type &&	_Keyval,
		_Mappedty &&	_Mapval
	)

inline

         {   // assign if _Keyval present, else insert, ignore hint
         return (_Insert_or_assign(_STD move(_Keyval),
             _STD forward<_Mappedty>(_Mapval)).first);
         }

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 (_Mybase::_Traitsobj._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= ( initializer_list< value_type > _Ilist )

inline

         {   // assign initializer_list
         _Mybase::clear();
         insert(_Ilist);
         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
         return (try_emplace(_STD move(_Keyval)).first->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
         return (try_emplace(_Keyval).first->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);
         }

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

template<class... _Mappedty>

_Pairib unordered_map< _Kty, _Ty, _Hasher, _Keyeq, _Alloc >::try_emplace	(	const key_type &	_Keyval,
		_Mappedty &&...	_Mapval
	)

inline

         {   // fail if _Keyval present, else emplace
         return (_Try_emplace(_Keyval, _STD forward<_Mappedty>(_Mapval)...));
         }

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

template<class... _Mappedty>

iterator unordered_map< _Kty, _Ty, _Hasher, _Keyeq, _Alloc >::try_emplace	(	const_iterator	,
		const key_type &	_Keyval,
		_Mappedty &&...	_Mapval
	)

inline

         {   // fail if _Keyval present, else emplace, ignore hint
         return (_Try_emplace(_Keyval,
             _STD forward<_Mappedty>(_Mapval)...).first);
         }

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

template<class... _Mappedty>

_Pairib unordered_map< _Kty, _Ty, _Hasher, _Keyeq, _Alloc >::try_emplace	(	key_type &&	_Keyval,
		_Mappedty &&...	_Mapval
	)

inline

         {   // fail if _Keyval present, else emplace
         return (_Try_emplace(_STD move(_Keyval),
             _STD forward<_Mappedty>(_Mapval)...));
         }

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

template<class... _Mappedty>

iterator unordered_map< _Kty, _Ty, _Hasher, _Keyeq, _Alloc >::try_emplace	(	const_iterator	,
		key_type &&	_Keyval,
		_Mappedty &&...	_Mapval
	)

inline

         {   // fail if _Keyval present, else emplace, ignore hint
         return (_Try_emplace(_STD move(_Keyval),
             _STD forward<_Mappedty>(_Mapval)...).first);
         }

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

VS2017/inc/unordered_map