STLdoc: stdext::hash_map< _Kty, _Ty, _Tr, _Alloc > Class Template Reference

STLdoc

STLdocumentation

All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros

Inheritance diagram for stdext::hash_map< _Kty, _Ty, _Tr, _Alloc >:

Public Types
typedef hash_map< _Kty, _Ty, _Tr, _Alloc >	_Myt

typedef _Hash< _Hmap_traits< _Kty, _Ty, _Tr, _Alloc, false > >	_Mybase

typedef _Kty	key_type

typedef _Ty	mapped_type

typedef _Ty	referent_type

typedef _Tr	key_compare

typedef _Mybase::value_compare	value_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::_Pairib	_Pairib

typedef _STD reverse_iterator< iterator >	reverse_iterator

typedef _STD reverse_iterator< const_iterator >	const_reverse_iterator

Public Types inherited from _Hash< _Traits >
enum	{ _Bucket_size = key_compare::bucket_size, _Min_buckets = 8, _Multi = _Traits::_Multi }

typedef _Hash< _Traits >	_Myt

typedef _Traits::key_type	key_type

typedef _Traits::key_compare	key_compare

typedef _Traits::value_compare	value_compare

typedef list< typename _Traits::value_type, typename _Traits::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
	hash_map ()

	hash_map (const allocator_type &_Al)

	hash_map (const _Myt &_Right)

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

	hash_map (const key_compare &_Traits)

	hash_map (const key_compare &_Traits, const allocator_type &_Al)

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

template<class _Iter >
	hash_map (_Iter _First, _Iter _Last, const key_compare &_Traits)

template<class _Iter >
	hash_map (_Iter _First, _Iter _Last, const key_compare &_Traits, const allocator_type &_Al)

_Myt &	operator= (const _Myt &_Right)

	hash_map (_Myt &&_Right)

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

_Myt &	operator= (_Myt &&_Right)

mapped_type &	operator[] (key_type &&_Keyval)

void	swap (_Myt &_Right)

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)

	hash_map (_STD initializer_list< value_type > _Ilist)

	hash_map (_STD initializer_list< value_type > _Ilist, const key_compare &_Pred)

	hash_map (_STD initializer_list< value_type > _Ilist, const key_compare &_Pred, const allocator_type &_Al)

_Myt &	operator= (_STD initializer_list< value_type > _Ilist)

mapped_type &	operator[] (const key_type &_Keyval)

mapped_type &	at (const key_type &_Keyval)

const mapped_type &	at (const key_type &_Keyval) const

reverse_iterator	rbegin () _NOEXCEPT

const_reverse_iterator	rbegin () const _NOEXCEPT

reverse_iterator	rend () _NOEXCEPT

const_reverse_iterator	rend () const _NOEXCEPT

const_reverse_iterator	crbegin () const _NOEXCEPT

const_reverse_iterator	crend () const _NOEXCEPT

Public Member Functions inherited from _Hash< _Traits >
	_Hash (const key_compare &_Parg, const allocator_type &_Al)

template<class _Any_alloc >
	_Hash (const _Myt &_Right, const _Any_alloc &_Al)

	_Hash (_Myt &&_Right)

template<class _Iter >
void	_Move_nodes (_Iter _First, _Iter _Last, true_type)

template<class _Iter >
void	_Move_nodes (_Iter _First, _Iter _Last, false_type)

template<class _Other >
void	_Move_assign_list (_Other &_Right, true_type)

template<class _Other >
void	_Move_assign_list (_Other &_Right, false_type)

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

_Myt &	operator= (_Myt &&_Right)

template<class... _Valty>
_Pairib	emplace (_Valty &&..._Val)

template<class... _Valty>
iterator	emplace_hint (const_iterator, _Valty &&..._Val)

	~_Hash () _NOEXCEPT

_Myt &	operator= (const _Myt &_Right)

iterator	begin () _NOEXCEPT

const_iterator	begin () const _NOEXCEPT

iterator	end () _NOEXCEPT

const_iterator	end () const _NOEXCEPT

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

local_iterator	begin (size_type _Bucket)

const_local_iterator	begin (size_type _Bucket) const

local_iterator	end (size_type _Bucket)

const_local_iterator	end (size_type _Bucket) const

const_local_iterator	cbegin (size_type _Bucket) const

const_local_iterator	cend (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)

template<bool _Multi2 = _Multi, enable_if_t<!_Multi2, int > = 0>
_Pairib	insert (const value_type &_Val)

template<bool _Multi2 = _Multi, enable_if_t< _Multi2, int > = 0>
iterator	insert (const value_type &_Val)

template<bool _Multi2 = _Multi, enable_if_t<!_Multi2, int > = 0>
_Pairib	insert (value_type &&_Val)

template<bool _Multi2 = _Multi, enable_if_t< _Multi2, int > = 0>
iterator	insert (value_type &&_Val)

iterator	insert (const_iterator, const value_type &_Val)

iterator	insert (const_iterator, value_type &&_Val)

template<class _Iter >
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< _Traits >
template<class _Valty >
_Unchecked_iterator	_Buynode_if_nil (_Valty &&, _Unchecked_iterator _Plist)

template<class _Valty >
_Unchecked_iterator	_Buynode_if_nil (_Valty &&_Val, _Nil)

void	_Destroy_if_not_nil (_Unchecked_iterator _Plist)

void	_Destroy_if_not_nil (_Nil)

template<class _Valty , class _Nodety >
_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< _Traits >
_Traits	_Traitsobj

_Mylist	_List

_Myvec	_Vec

size_type	_Mask

size_type	_Maxidx

Member Typedef Documentation

template<class _Kty, class _Ty, class _Tr = hash_compare<_Kty, less<_Kty> >, class _Alloc = allocator<pair<const _Kty, _Ty> >>

typedef _Hash<_Hmap_traits<_Kty, _Ty, _Tr, _Alloc, false> > stdext::hash_map< _Kty, _Ty, _Tr, _Alloc >::_Mybase

template<class _Kty, class _Ty, class _Tr = hash_compare<_Kty, less<_Kty> >, class _Alloc = allocator<pair<const _Kty, _Ty> >>

typedef hash_map<_Kty, _Ty, _Tr, _Alloc> stdext::hash_map< _Kty, _Ty, _Tr, _Alloc >::_Myt

template<class _Kty, class _Ty, class _Tr = hash_compare<_Kty, less<_Kty> >, class _Alloc = allocator<pair<const _Kty, _Ty> >>

typedef _Mybase::_Pairib stdext::hash_map< _Kty, _Ty, _Tr, _Alloc >::_Pairib

template<class _Kty, class _Ty, class _Tr = hash_compare<_Kty, less<_Kty> >, class _Alloc = allocator<pair<const _Kty, _Ty> >>

typedef _Mybase::allocator_type stdext::hash_map< _Kty, _Ty, _Tr, _Alloc >::allocator_type

template<class _Kty, class _Ty, class _Tr = hash_compare<_Kty, less<_Kty> >, class _Alloc = allocator<pair<const _Kty, _Ty> >>

typedef _Mybase::const_iterator stdext::hash_map< _Kty, _Ty, _Tr, _Alloc >::const_iterator

template<class _Kty, class _Ty, class _Tr = hash_compare<_Kty, less<_Kty> >, class _Alloc = allocator<pair<const _Kty, _Ty> >>

typedef _Mybase::const_pointer stdext::hash_map< _Kty, _Ty, _Tr, _Alloc >::const_pointer

template<class _Kty, class _Ty, class _Tr = hash_compare<_Kty, less<_Kty> >, class _Alloc = allocator<pair<const _Kty, _Ty> >>

typedef _Mybase::const_reference stdext::hash_map< _Kty, _Ty, _Tr, _Alloc >::const_reference

template<class _Kty, class _Ty, class _Tr = hash_compare<_Kty, less<_Kty> >, class _Alloc = allocator<pair<const _Kty, _Ty> >>

typedef _STD reverse_iterator<const_iterator> stdext::hash_map< _Kty, _Ty, _Tr, _Alloc >::const_reverse_iterator

template<class _Kty, class _Ty, class _Tr = hash_compare<_Kty, less<_Kty> >, class _Alloc = allocator<pair<const _Kty, _Ty> >>

typedef _Mybase::difference_type stdext::hash_map< _Kty, _Ty, _Tr, _Alloc >::difference_type

template<class _Kty, class _Ty, class _Tr = hash_compare<_Kty, less<_Kty> >, class _Alloc = allocator<pair<const _Kty, _Ty> >>

typedef _Mybase::iterator stdext::hash_map< _Kty, _Ty, _Tr, _Alloc >::iterator

template<class _Kty, class _Ty, class _Tr = hash_compare<_Kty, less<_Kty> >, class _Alloc = allocator<pair<const _Kty, _Ty> >>

typedef _Tr stdext::hash_map< _Kty, _Ty, _Tr, _Alloc >::key_compare

template<class _Kty, class _Ty, class _Tr = hash_compare<_Kty, less<_Kty> >, class _Alloc = allocator<pair<const _Kty, _Ty> >>

typedef _Kty stdext::hash_map< _Kty, _Ty, _Tr, _Alloc >::key_type

template<class _Kty, class _Ty, class _Tr = hash_compare<_Kty, less<_Kty> >, class _Alloc = allocator<pair<const _Kty, _Ty> >>

typedef _Ty stdext::hash_map< _Kty, _Ty, _Tr, _Alloc >::mapped_type

template<class _Kty, class _Ty, class _Tr = hash_compare<_Kty, less<_Kty> >, class _Alloc = allocator<pair<const _Kty, _Ty> >>

typedef _Mybase::pointer stdext::hash_map< _Kty, _Ty, _Tr, _Alloc >::pointer

template<class _Kty, class _Ty, class _Tr = hash_compare<_Kty, less<_Kty> >, class _Alloc = allocator<pair<const _Kty, _Ty> >>

typedef _Mybase::reference stdext::hash_map< _Kty, _Ty, _Tr, _Alloc >::reference

template<class _Kty, class _Ty, class _Tr = hash_compare<_Kty, less<_Kty> >, class _Alloc = allocator<pair<const _Kty, _Ty> >>

typedef _Ty stdext::hash_map< _Kty, _Ty, _Tr, _Alloc >::referent_type

template<class _Kty, class _Ty, class _Tr = hash_compare<_Kty, less<_Kty> >, class _Alloc = allocator<pair<const _Kty, _Ty> >>

typedef _STD reverse_iterator<iterator> stdext::hash_map< _Kty, _Ty, _Tr, _Alloc >::reverse_iterator

template<class _Kty, class _Ty, class _Tr = hash_compare<_Kty, less<_Kty> >, class _Alloc = allocator<pair<const _Kty, _Ty> >>

typedef _Mybase::size_type stdext::hash_map< _Kty, _Ty, _Tr, _Alloc >::size_type

template<class _Kty, class _Ty, class _Tr = hash_compare<_Kty, less<_Kty> >, class _Alloc = allocator<pair<const _Kty, _Ty> >>

typedef _Mybase::value_compare stdext::hash_map< _Kty, _Ty, _Tr, _Alloc >::value_compare

template<class _Kty, class _Ty, class _Tr = hash_compare<_Kty, less<_Kty> >, class _Alloc = allocator<pair<const _Kty, _Ty> >>

typedef _Mybase::value_type stdext::hash_map< _Kty, _Ty, _Tr, _Alloc >::value_type

Constructor & Destructor Documentation

template<class _Kty, class _Ty, class _Tr = hash_compare<_Kty, less<_Kty> >, class _Alloc = allocator<pair<const _Kty, _Ty> >>

stdext::hash_map< _Kty, _Ty, _Tr, _Alloc >::hash_map ( )

inline

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

template<class _Kty, class _Ty, class _Tr = hash_compare<_Kty, less<_Kty> >, class _Alloc = allocator<pair<const _Kty, _Ty> >>

stdext::hash_map< _Kty, _Ty, _Tr, _Alloc >::hash_map ( const allocator_type & _Al )

inlineexplicit

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

template<class _Kty, class _Ty, class _Tr = hash_compare<_Kty, less<_Kty> >, class _Alloc = allocator<pair<const _Kty, _Ty> >>

stdext::hash_map< _Kty, _Ty, _Tr, _Alloc >::hash_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 _Tr = hash_compare<_Kty, less<_Kty> >, class _Alloc = allocator<pair<const _Kty, _Ty> >>

stdext::hash_map< _Kty, _Ty, _Tr, _Alloc >::hash_map	(	const _Myt &	_Right,
		const allocator_type &	_Al
	)

inline

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

template<class _Kty, class _Ty, class _Tr = hash_compare<_Kty, less<_Kty> >, class _Alloc = allocator<pair<const _Kty, _Ty> >>

stdext::hash_map< _Kty, _Ty, _Tr, _Alloc >::hash_map ( const key_compare & _Traits )

inlineexplicit

         : _Mybase(_Traits, allocator_type())
         {   // construct empty map from comparator
         }

template<class _Kty, class _Ty, class _Tr = hash_compare<_Kty, less<_Kty> >, class _Alloc = allocator<pair<const _Kty, _Ty> >>

stdext::hash_map< _Kty, _Ty, _Tr, _Alloc >::hash_map	(	const key_compare &	_Traits,
		const allocator_type &	_Al
	)

inline

         : _Mybase(_Traits, _Al)
         {   // construct empty map from comparator and allocator
         }

template<class _Kty, class _Ty, class _Tr = hash_compare<_Kty, less<_Kty> >, class _Alloc = allocator<pair<const _Kty, _Ty> >>

template<class _Iter >

stdext::hash_map< _Kty, _Ty, _Tr, _Alloc >::hash_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 _Tr = hash_compare<_Kty, less<_Kty> >, class _Alloc = allocator<pair<const _Kty, _Ty> >>

template<class _Iter >

stdext::hash_map< _Kty, _Ty, _Tr, _Alloc >::hash_map	(	_Iter	_First,
		_Iter	_Last,
		const key_compare &	_Traits
	)

inline

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

template<class _Kty, class _Ty, class _Tr = hash_compare<_Kty, less<_Kty> >, class _Alloc = allocator<pair<const _Kty, _Ty> >>

template<class _Iter >

stdext::hash_map< _Kty, _Ty, _Tr, _Alloc >::hash_map	(	_Iter	_First,
		_Iter	_Last,
		const key_compare &	_Traits,
		const allocator_type &	_Al
	)

inline

         : _Mybase(_Traits, _Al)
         {   // construct map from sequence, comparator, and allocator
         insert(_First, _Last);
         }

template<class _Kty, class _Ty, class _Tr = hash_compare<_Kty, less<_Kty> >, class _Alloc = allocator<pair<const _Kty, _Ty> >>

stdext::hash_map< _Kty, _Ty, _Tr, _Alloc >::hash_map ( _Myt && _Right )

inline

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

template<class _Kty, class _Ty, class _Tr = hash_compare<_Kty, less<_Kty> >, class _Alloc = allocator<pair<const _Kty, _Ty> >>

stdext::hash_map< _Kty, _Ty, _Tr, _Alloc >::hash_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 _Tr = hash_compare<_Kty, less<_Kty> >, class _Alloc = allocator<pair<const _Kty, _Ty> >>

stdext::hash_map< _Kty, _Ty, _Tr, _Alloc >::hash_map ( _STD initializer_list< value_type > _Ilist )

inline

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

template<class _Kty, class _Ty, class _Tr = hash_compare<_Kty, less<_Kty> >, class _Alloc = allocator<pair<const _Kty, _Ty> >>

stdext::hash_map< _Kty, _Ty, _Tr, _Alloc >::hash_map	(	_STD initializer_list< value_type >	_Ilist,
		const key_compare &	_Pred
	)

inline

         : _Mybase(_Pred, allocator_type())
         {   // construct from initializer_list, comparator
         insert(_Ilist);
         }

template<class _Kty, class _Ty, class _Tr = hash_compare<_Kty, less<_Kty> >, class _Alloc = allocator<pair<const _Kty, _Ty> >>

stdext::hash_map< _Kty, _Ty, _Tr, _Alloc >::hash_map	(	_STD initializer_list< value_type >	_Ilist,
		const key_compare &	_Pred,
		const allocator_type &	_Al
	)

inline

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

Member Function Documentation

template<class _Kty, class _Ty, class _Tr = hash_compare<_Kty, less<_Kty> >, class _Alloc = allocator<pair<const _Kty, _Ty> >>

mapped_type& stdext::hash_map< _Kty, _Ty, _Tr, _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 hash_map<K, T> key");
         return (_Where->second);
         }

template<class _Kty, class _Ty, class _Tr = hash_compare<_Kty, less<_Kty> >, class _Alloc = allocator<pair<const _Kty, _Ty> >>

const mapped_type& stdext::hash_map< _Kty, _Ty, _Tr, _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 hash_map<K, T> key");
         return (_Where->second);
         }

template<class _Kty, class _Ty, class _Tr = hash_compare<_Kty, less<_Kty> >, class _Alloc = allocator<pair<const _Kty, _Ty> >>

const_reverse_iterator stdext::hash_map< _Kty, _Ty, _Tr, _Alloc >::crbegin ( ) const

inline

         {   // return iterator for beginning of reversed nonmutable sequence
         return (rbegin());
         }

template<class _Kty, class _Ty, class _Tr = hash_compare<_Kty, less<_Kty> >, class _Alloc = allocator<pair<const _Kty, _Ty> >>

const_reverse_iterator stdext::hash_map< _Kty, _Ty, _Tr, _Alloc >::crend ( ) const

inline

         {   // return iterator for end of reversed nonmutable sequence
         return (rend());
         }

template<class _Kty, class _Ty, class _Tr = hash_compare<_Kty, less<_Kty> >, class _Alloc = allocator<pair<const _Kty, _Ty> >>

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

_Pairib stdext::hash_map< _Kty, _Ty, _Tr, _Alloc >::insert ( _Valty && _Val )

inline

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

template<class _Kty, class _Ty, class _Tr = hash_compare<_Kty, less<_Kty> >, class _Alloc = allocator<pair<const _Kty, _Ty> >>

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

iterator stdext::hash_map< _Kty, _Ty, _Tr, _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 _Tr = hash_compare<_Kty, less<_Kty> >, class _Alloc = allocator<pair<const _Kty, _Ty> >>

_Myt& stdext::hash_map< _Kty, _Ty, _Tr, _Alloc >::operator= ( const _Myt & _Right )

inline

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

template<class _Kty, class _Ty, class _Tr = hash_compare<_Kty, less<_Kty> >, class _Alloc = allocator<pair<const _Kty, _Ty> >>

_Myt& stdext::hash_map< _Kty, _Ty, _Tr, _Alloc >::operator= ( _Myt && _Right )

inline

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

template<class _Kty, class _Ty, class _Tr = hash_compare<_Kty, less<_Kty> >, class _Alloc = allocator<pair<const _Kty, _Ty> >>

_Myt& stdext::hash_map< _Kty, _Ty, _Tr, _Alloc >::operator= ( _STD initializer_list< value_type > _Ilist )

inline

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

template<class _Kty, class _Ty, class _Tr = hash_compare<_Kty, less<_Kty> >, class _Alloc = allocator<pair<const _Kty, _Ty> >>

mapped_type& stdext::hash_map< _Kty, _Ty, _Tr, _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 = insert(
                 pair<key_type, mapped_type>(
                     _STD move(_Keyval),
                     mapped_type())).first;
         return (_Where->second);
         }

template<class _Kty, class _Ty, class _Tr = hash_compare<_Kty, less<_Kty> >, class _Alloc = allocator<pair<const _Kty, _Ty> >>

mapped_type& stdext::hash_map< _Kty, _Ty, _Tr, _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 = insert(
                 pair<key_type, mapped_type>(
                     _Keyval,
                     mapped_type())).first;
         return (_Where->second);
         }

template<class _Kty, class _Ty, class _Tr = hash_compare<_Kty, less<_Kty> >, class _Alloc = allocator<pair<const _Kty, _Ty> >>

reverse_iterator stdext::hash_map< _Kty, _Ty, _Tr, _Alloc >::rbegin ( )

inline

         {   // return iterator for beginning of reversed mutable sequence
         return (reverse_iterator(this->end()));
         }

template<class _Kty, class _Ty, class _Tr = hash_compare<_Kty, less<_Kty> >, class _Alloc = allocator<pair<const _Kty, _Ty> >>

const_reverse_iterator stdext::hash_map< _Kty, _Ty, _Tr, _Alloc >::rbegin ( ) const

inline

         {   // return iterator for beginning of reversed nonmutable sequence
         return (const_reverse_iterator(this->end()));
         }

template<class _Kty, class _Ty, class _Tr = hash_compare<_Kty, less<_Kty> >, class _Alloc = allocator<pair<const _Kty, _Ty> >>

reverse_iterator stdext::hash_map< _Kty, _Ty, _Tr, _Alloc >::rend ( )

inline

         {   // return iterator for end of reversed mutable sequence
         return (reverse_iterator(this->begin()));
         }

template<class _Kty, class _Ty, class _Tr = hash_compare<_Kty, less<_Kty> >, class _Alloc = allocator<pair<const _Kty, _Ty> >>

const_reverse_iterator stdext::hash_map< _Kty, _Ty, _Tr, _Alloc >::rend ( ) const

inline

         {   // return iterator for end of reversed nonmutable sequence
         return (const_reverse_iterator(this->begin()));
         }

template<class _Kty, class _Ty, class _Tr = hash_compare<_Kty, less<_Kty> >, class _Alloc = allocator<pair<const _Kty, _Ty> >>

void stdext::hash_map< _Kty, _Ty, _Tr, _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/hash_map