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

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

Public Types
typedef hash_multimap< _Kty, _Ty, _Tr, _Alloc >	_Myt
typedef _Hash< _Hmap_traits< _Kty, _Ty, _Tr, _Alloc, true > >	_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 _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_multimap ()
	hash_multimap (const allocator_type &_Al)
	hash_multimap (const _Myt &_Right)
	hash_multimap (const _Myt &_Right, const allocator_type &_Al)
	hash_multimap (const key_compare &_Traits)
	hash_multimap (const key_compare &_Traits, const allocator_type &_Al)
template<class _Iter >
	hash_multimap (_Iter _First, _Iter _Last)
template<class _Iter >
	hash_multimap (_Iter _First, _Iter _Last, const key_compare &_Traits)
template<class _Iter >
	hash_multimap (_Iter _First, _Iter _Last, const key_compare &_Traits, const allocator_type &_Al)
_Myt &	operator= (const _Myt &_Right)
	hash_multimap (_Myt &&_Right)
	hash_multimap (_Myt &&_Right, const allocator_type &_Al)
_Myt &	operator= (_Myt &&_Right)
void	swap (_Myt &_Right)
template<class _Valty , class = enable_if_t<is_constructible<value_type, _Valty>::value>>
iterator	insert (_Valty &&_Val)
template<class _Valty , class = enable_if_t<is_constructible<value_type, _Valty>::value>>
iterator	insert (const_iterator _Where, _Valty &&_Val)
	hash_multimap (_STD initializer_list< value_type > _Ilist)
	hash_multimap (_STD initializer_list< value_type > _Ilist, const key_compare &_Pred)
	hash_multimap (_STD initializer_list< value_type > _Ilist, const key_compare &_Pred, const allocator_type &_Al)
_Myt &	operator= (_STD initializer_list< value_type > _Ilist)
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, true> > stdext::hash_multimap< _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_multimap<_Kty, _Ty, _Tr, _Alloc> stdext::hash_multimap< _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::allocator_type stdext::hash_multimap< _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_multimap< _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_multimap< _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_multimap< _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_multimap< _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_multimap< _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_multimap< _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_multimap< _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_multimap< _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_multimap< _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_multimap< _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_multimap< _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_multimap< _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_multimap< _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_multimap< _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_multimap< _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_multimap< _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_multimap< _Kty, _Ty, _Tr, _Alloc >::hash_multimap ( )

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_multimap< _Kty, _Ty, _Tr, _Alloc >::hash_multimap ( 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_multimap< _Kty, _Ty, _Tr, _Alloc >::hash_multimap ( 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_multimap< _Kty, _Ty, _Tr, _Alloc >::hash_multimap ( 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_multimap< _Kty, _Ty, _Tr, _Alloc >::hash_multimap ( 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_multimap< _Kty, _Ty, _Tr, _Alloc >::hash_multimap ( 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_multimap< _Kty, _Ty, _Tr, _Alloc >::hash_multimap ( _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_multimap< _Kty, _Ty, _Tr, _Alloc >::hash_multimap ( _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_multimap< _Kty, _Ty, _Tr, _Alloc >::hash_multimap ( _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_multimap< _Kty, _Ty, _Tr, _Alloc >::hash_multimap ( _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_multimap< _Kty, _Ty, _Tr, _Alloc >::hash_multimap ( _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_multimap< _Kty, _Ty, _Tr, _Alloc >::hash_multimap ( _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_multimap< _Kty, _Ty, _Tr, _Alloc >::hash_multimap ( _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_multimap< _Kty, _Ty, _Tr, _Alloc >::hash_multimap ( _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> >>

const_reverse_iterator stdext::hash_multimap< _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_multimap< _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>>

iterator stdext::hash_multimap< _Kty, _Ty, _Tr, _Alloc >::insert ( _Valty &&  _Val )

inline

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

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

reverse_iterator stdext::hash_multimap< _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_multimap< _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_multimap< _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_multimap< _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_multimap< _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