multimap< _Kty, _Ty, _Pr, _Alloc > Class Template Reference

Inheritance diagram for multimap< _Kty, _Ty, _Pr, _Alloc >:

Public Types
typedef multimap< _Kty, _Ty, _Pr, _Alloc >	_Myt
typedef _Tree< _Tmap_traits< _Kty, _Ty, _Pr, _Alloc, true > >	_Mybase
typedef _Kty	key_type
typedef _Ty	mapped_type
typedef _Pr	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::reverse_iterator	reverse_iterator
typedef _Mybase::const_reverse_iterator	const_reverse_iterator
typedef _Mybase::value_type	value_type
typedef _Mybase::_Alty	_Alty
Public Types inherited from _Tree< _Tmap_traits< _Kty, _Ty, _Pr, _Alloc, true > >
enum
typedef _Tree< _Tmap_traits< _Kty, _Ty, _Pr, _Alloc, true > >	_Myt
typedef _Tree_comp_alloc< _Tmap_traits< _Kty, _Ty, _Pr, _Alloc, true > >	_Mybase
typedef _Tmap_traits< _Kty, _Ty, _Pr, _Alloc, true >::key_type	key_type
typedef _Tmap_traits< _Kty, _Ty, _Pr, _Alloc, true >::value_compare	value_compare
typedef _Mybase::_Node	_Node
typedef _Mybase::_Nodeptr	_Nodeptr
typedef _Mybase::_Alty	_Alty
typedef _Mybase::key_compare	key_compare
typedef _Mybase::allocator_type	allocator_type
typedef _Mybase::value_type	value_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::const_iterator	const_iterator
typedef _If< is_same< key_type, value_type >::value, typename _Mybase::const_iterator, typename _Mybase::iterator >::type	iterator
typedef _STD reverse_iterator< iterator >	reverse_iterator
typedef _STD reverse_iterator< const_iterator >	const_reverse_iterator
typedef pair< iterator, bool >	_Pairib
typedef pair< iterator, iterator >	_Pairii
typedef pair< const_iterator, const_iterator >	_Paircc
Public Types inherited from _Tree_comp_alloc< _Tmap_traits< _Kty, _Ty, _Pr, _Alloc, true > >
enum	_Redbl
typedef _Tree_comp_alloc< _Tmap_traits< _Kty, _Ty, _Pr, _Alloc, true > >	_Myt
typedef _Tmap_traits< _Kty, _Ty, _Pr, _Alloc, true >::allocator_type	allocator_type
typedef _Tmap_traits< _Kty, _Ty, _Pr, _Alloc, true >::key_compare	key_compare
typedef _Tree_base_types< typename _Tmap_traits< _Kty, _Ty, _Pr, _Alloc, true >::value_type, allocator_type >	_Alloc_types
typedef _Alloc_types::_Alloc	_Alloc
typedef _Alloc_types::_Alnod_type	_Alty
typedef _Alloc_types::_Node	_Node
typedef _Alloc_types::_Nodeptr	_Nodeptr
typedef _Alloc_types::_Val_types	_Val_types
typedef _Nodeptr &	_Nodepref
typedef _Val_types::value_type	value_type
typedef _Val_types::size_type	size_type
typedef _Val_types::difference_type	difference_type
typedef _Val_types::pointer	pointer
typedef _Val_types::const_pointer	const_pointer
typedef _Val_types::reference	reference
typedef _Val_types::const_reference	const_reference
typedef _Tree_const_iterator< _Tree_val< _Val_types > >	const_iterator
typedef _Tree_iterator< _Tree_val< _Val_types > >	iterator

Public Member Functions
	multimap ()
	multimap (const allocator_type &_Al)
	multimap (const _Myt &_Right)
	multimap (const _Myt &_Right, const allocator_type &_Al)
	multimap (const key_compare &_Pred)
	multimap (const key_compare &_Pred, const allocator_type &_Al)
template<class _Iter >
	multimap (_Iter _First, _Iter _Last)
template<class _Iter >
	multimap (_Iter _First, _Iter _Last, const key_compare &_Pred)
template<class _Iter >
	multimap (_Iter _First, _Iter _Last, const key_compare &_Pred, const allocator_type &_Al)
_Myt &	operator= (const _Myt &_Right)
	multimap (_Myt &&_Right)
	multimap (_Myt &&_Right, const allocator_type &_Al)
_Myt &	operator= (_Myt &&_Right) _NOEXCEPT_OP(_Alty
template<class... _Valty>
iterator	emplace (_Valty &&..._Val)
void	swap (_Myt &_Right) _NOEXCEPT_OP(_Alty
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)
	multimap (_XSTD initializer_list< value_type > _Ilist)
	multimap (_XSTD initializer_list< value_type > _Ilist, const key_compare &_Pred)
	multimap (_XSTD initializer_list< value_type > _Ilist, const key_compare &_Pred, const allocator_type &_Al)
_Myt &	operator= (_XSTD initializer_list< value_type > _Ilist)
Public Member Functions inherited from _Tree< _Tmap_traits< _Kty, _Ty, _Pr, _Alloc, true > >
	_Tree (const key_compare &_Parg)
	_Tree (const key_compare &_Parg, const allocator_type &_Al)
	_Tree (const _Myt &_Right, _Any_alloc &&_Al)
	_Tree (_Myt &&_Right)
	_Tree (_Myt &&_Right, const allocator_type &_Al)
_Myt &	operator= (_Myt &&_Right)
_Myt &	operator= (const _Myt &_Right)
void	_Assign_rv (_Myt &&_Right, true_type)
void	_Assign_rv (_Myt &&_Right, false_type)
void	_Assign_rv (_Myt &&_Right)
_Pairib	emplace (_Valty &&..._Val)
iterator	emplace_hint (const_iterator _Where, _Valty &&..._Val)
	~_Tree () _NOEXCEPT
iterator	begin () _NOEXCEPT
const_iterator	begin () const _NOEXCEPT
iterator	end () _NOEXCEPT
const_iterator	end () const _NOEXCEPT
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_iterator	cend () 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
_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 _Where, const value_type &_Val)
iterator	insert (const_iterator _Where, value_type &&_Val)
void	insert (_Iter _First, _Iter _Last)
void	insert (_XSTD initializer_list< value_type > _Ilist)
iterator	erase (const_iterator _Where)
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
iterator	find (const _Other &_Keyval)
const_iterator	find (const _Other &_Keyval) const
size_type	count (const key_type &_Keyval) const
size_type	count (const _Other &_Keyval) const
iterator	lower_bound (const key_type &_Keyval)
const_iterator	lower_bound (const key_type &_Keyval) const
iterator	lower_bound (const _Other &_Keyval)
const_iterator	lower_bound (const _Other &_Keyval) const
iterator	upper_bound (const key_type &_Keyval)
const_iterator	upper_bound (const key_type &_Keyval) const
iterator	upper_bound (const _Other &_Keyval)
const_iterator	upper_bound (const _Other &_Keyval) const
_Pairii	equal_range (const key_type &_Keyval)
_Paircc	equal_range (const key_type &_Keyval) const
_Pairii	equal_range (const _Other &_Keyval)
_Paircc	equal_range (const _Other &_Keyval) const
void	swap (_Myt &_Right)
Public Member Functions inherited from _Tree_comp_alloc< _Tmap_traits< _Kty, _Ty, _Pr, _Alloc, true > >
	_Tree_comp_alloc (const key_compare &_Parg)
	_Tree_comp_alloc (const key_compare &_Parg, _Any_alloc &&_Al)
void	_Construct ()
	~_Tree_comp_alloc () _NOEXCEPT
void	_Copy_alloc (const _Alty &_Al)
void	_Move_alloc (_Alty &_Al)
void	_Orphan_all ()
void	_Swap_all (_Myt &_Right)
_Nodeptr	_Buyheadnode ()
void	_Freeheadnode (_Nodeptr _Pnode)
_Nodeptr	_Buynode0 ()
void	_Freenode0 (_Nodeptr _Pnode)
_Nodeptr	_Buynode (_Valty &&..._Val)
key_compare &	_Getcomp () _NOEXCEPT
const key_compare &	_Getcomp () const _NOEXCEPT
_Alty &	_Getal () _NOEXCEPT
const _Alty &	_Getal () const _NOEXCEPT
_Tree_val< _Val_types > &	_Get_data () _NOEXCEPT
const _Tree_val< _Val_types > &	_Get_data () const _NOEXCEPT
_Nodeptr &	_Myhead () _NOEXCEPT
const _Nodeptr &	_Myhead () const _NOEXCEPT
size_type &	_Mysize () _NOEXCEPT
const size_type &	_Mysize () const _NOEXCEPT

Additional Inherited Members
Static Public Member Functions inherited from _Tree_comp_alloc< _Tmap_traits< _Kty, _Ty, _Pr, _Alloc, true > >
static char &	_Color (_Nodeptr _Pnode)
static char &	_Isnil (_Nodeptr _Pnode)
static _Nodepref	_Left (_Nodeptr _Pnode)
static _Nodepref	_Parent (_Nodeptr _Pnode)
static _Nodepref	_Right (_Nodeptr _Pnode)
static reference	_Myval (_Nodeptr _Pnode)
static _Nodeptr	_Max (_Nodeptr _Pnode)
static _Nodeptr	_Min (_Nodeptr _Pnode)
Protected Member Functions inherited from _Tree< _Tmap_traits< _Kty, _Ty, _Pr, _Alloc, true > >
_Nodeptr	_Buynode_if_nil (_Nodeptr _Node, _Valty &&)
_Nodeptr	_Buynode_if_nil (_Nil, _Valty &&_Val)
void	_Destroy_if_not_nil (_Nodeptr _Newnode)
void	_Destroy_if_not_nil (_Nil)
iterator	_Insert_hint (const_iterator _Where, _Valty &&_Val, _Nodety _Newnode)
_Pairib	_Insert_nohint (bool _Leftish, _Valty &&_Val, _Nodety _Newnode)
iterator	_Insert_at (bool _Addleft, _Nodeptr _Wherenode, _Valty &&_Val, _Nodety _Node)
void	_Copy (const _Myt &_Right, _Moveit _Movefl)
_Nodeptr	_Copy_or_move (_Ty &_Val, _Copy_tag, _Is_set)
_Nodeptr	_Copy_or_move (_Ty &_Val, _Move_tag, true_type)
_Nodeptr	_Copy_or_move (_Ty &_Val, _Move_tag, false_type)
_Nodeptr	_Copy_nodes (_Nodeptr _Rootnode, _Nodeptr _Wherenode, _Moveit _Movefl)
_Paircc	_Eqrange (const _Other &_Keyval) const
_Pairii	_Eqrange (const _Other &_Keyval)
void	_Erase (_Nodeptr _Rootnode)
bool	_Compare (const key_type &_Left, const key_type &_Right) const
bool	_Compare (const _Ty1 &_Left, const _Ty2 &_Right) const
_Nodeptr	_Lbound (const _Other &_Keyval) const
_Nodeptr &	_Lmost () const
void	_Lrotate (_Nodeptr _Wherenode)
_Nodeptr &	_Rmost () const
_Nodeptr &	_Root () const
void	_Rrotate (_Nodeptr _Wherenode)
_Nodeptr	_Ubound (const _Other &_Keyval) const
void	_Tidy ()
const key_type &	_Kfn (const value_type &_Val) const
const key_type &	_Key (_Nodeptr _Pnode) const

Member Typedef Documentation

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

typedef _Mybase::_Alty multimap< _Kty, _Ty, _Pr, _Alloc >::_Alty

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

typedef _Tree<_Tmap_traits<_Kty, _Ty, _Pr, _Alloc, true> > multimap< _Kty, _Ty, _Pr, _Alloc >::_Mybase

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

typedef multimap<_Kty, _Ty, _Pr, _Alloc> multimap< _Kty, _Ty, _Pr, _Alloc >::_Myt

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

typedef _Mybase::allocator_type multimap< _Kty, _Ty, _Pr, _Alloc >::allocator_type

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

typedef _Mybase::const_iterator multimap< _Kty, _Ty, _Pr, _Alloc >::const_iterator

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

typedef _Mybase::const_pointer multimap< _Kty, _Ty, _Pr, _Alloc >::const_pointer

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

typedef _Mybase::const_reference multimap< _Kty, _Ty, _Pr, _Alloc >::const_reference

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

typedef _Mybase::const_reverse_iterator multimap< _Kty, _Ty, _Pr, _Alloc >::const_reverse_iterator

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

typedef _Mybase::difference_type multimap< _Kty, _Ty, _Pr, _Alloc >::difference_type

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

typedef _Mybase::iterator multimap< _Kty, _Ty, _Pr, _Alloc >::iterator

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

typedef _Pr multimap< _Kty, _Ty, _Pr, _Alloc >::key_compare

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

typedef _Kty multimap< _Kty, _Ty, _Pr, _Alloc >::key_type

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

typedef _Ty multimap< _Kty, _Ty, _Pr, _Alloc >::mapped_type

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

typedef _Mybase::pointer multimap< _Kty, _Ty, _Pr, _Alloc >::pointer

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

typedef _Mybase::reference multimap< _Kty, _Ty, _Pr, _Alloc >::reference

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

typedef _Mybase::reverse_iterator multimap< _Kty, _Ty, _Pr, _Alloc >::reverse_iterator

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

typedef _Mybase::size_type multimap< _Kty, _Ty, _Pr, _Alloc >::size_type

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

typedef _Mybase::value_compare multimap< _Kty, _Ty, _Pr, _Alloc >::value_compare

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

typedef _Mybase::value_type multimap< _Kty, _Ty, _Pr, _Alloc >::value_type

Constructor & Destructor Documentation

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

multimap< _Kty, _Ty, _Pr, _Alloc >::multimap ( )

inline

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

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

multimap< _Kty, _Ty, _Pr, _Alloc >::multimap ( const allocator_type &  _Al )

inlineexplicit

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

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

multimap< _Kty, _Ty, _Pr, _Alloc >::multimap ( const _Myt &  _Right )

inline

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

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

multimap< _Kty, _Ty, _Pr, _Alloc >::multimap ( const _Myt &  _Right, const allocator_type &  _Al  )

inline

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

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

multimap< _Kty, _Ty, _Pr, _Alloc >::multimap ( const key_compare &  _Pred )

inlineexplicit

        : _Mybase(_Pred)
        {   // construct empty map from comparator
        }

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

multimap< _Kty, _Ty, _Pr, _Alloc >::multimap ( const key_compare &  _Pred, const allocator_type &  _Al  )

inline

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

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

template<class _Iter >

multimap< _Kty, _Ty, _Pr, _Alloc >::multimap ( _Iter  _First, _Iter  _Last  )

inline

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

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

template<class _Iter >

multimap< _Kty, _Ty, _Pr, _Alloc >::multimap ( _Iter  _First, _Iter  _Last, const key_compare &  _Pred  )

inline

        : _Mybase(_Pred)
        {   // construct map from [_First, _Last), comparator
        insert(_First, _Last);
        }

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

template<class _Iter >

multimap< _Kty, _Ty, _Pr, _Alloc >::multimap ( _Iter  _First, _Iter  _Last, const key_compare &  _Pred, const allocator_type &  _Al  )

inline

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

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

multimap< _Kty, _Ty, _Pr, _Alloc >::multimap ( _Myt &&  _Right )

inline

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

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

multimap< _Kty, _Ty, _Pr, _Alloc >::multimap ( _Myt &&  _Right, const allocator_type &  _Al  )

inline

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

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

multimap< _Kty, _Ty, _Pr, _Alloc >::multimap ( _XSTD initializer_list< value_type >  _Ilist )

inline

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

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

multimap< _Kty, _Ty, _Pr, _Alloc >::multimap ( _XSTD initializer_list< value_type >  _Ilist, const key_compare &  _Pred  )

inline

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

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

multimap< _Kty, _Ty, _Pr, _Alloc >::multimap ( _XSTD 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 _Pr = less<_Kty>, class _Alloc = allocator<pair<const _Kty, _Ty> >>

template<class... _Valty>

iterator multimap< _Kty, _Ty, _Pr, _Alloc >::emplace ( _Valty &&...  _Val )

inline

        {   // try to insert value_type(_Val...), favoring right side
        return (_Mybase::emplace(_STD forward<_Valty>(_Val)...).first);
        }

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

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

iterator multimap< _Kty, _Ty, _Pr, _Alloc >::insert ( _Valty &&  _Val )

inline

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

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

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

iterator multimap< _Kty, _Ty, _Pr, _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 _Pr = less<_Kty>, class _Alloc = allocator<pair<const _Kty, _Ty> >>

_Myt& multimap< _Kty, _Ty, _Pr, _Alloc >::operator= ( const _Myt &  _Right )

inline

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

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

_Myt& multimap< _Kty, _Ty, _Pr, _Alloc >::operator= ( _Myt &&  _Right )

inline

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

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

_Myt& multimap< _Kty, _Ty, _Pr, _Alloc >::operator= ( _XSTD initializer_list< value_type >  _Ilist )

inline

        {   // assign initializer_list
        _Mybase::clear();
        insert(_Ilist);
        return (*this);
        }

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

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

• VS2015/inc/map