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 _Ty	referent_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
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< !is_empty< typename _Tmap_traits< _Kty, _Ty, _Pr, _Alloc, true >::key_compare >::value, _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< !is_empty< _Tmap_traits< _Kty, _Ty, _Pr, _Alloc, true >::key_compare >::value, _Tmap_traits< _Kty, _Ty, _Pr, _Alloc, true > >
typedef _Tree_comp< _Pr_has_storage, _Tmap_traits< _Kty, _Ty, _Pr, _Alloc, true > >	_Myt
typedef _Tree_buy< typename _Tmap_traits< _Kty, _Ty, _Pr, _Alloc, true >::value_type, typename _Tmap_traits< _Kty, _Ty, _Pr, _Alloc, true >::allocator_type >	_Mybase
typedef _Tmap_traits< _Kty, _Ty, _Pr, _Alloc, true >::allocator_type	allocator_type
typedef _Tmap_traits< _Kty, _Ty, _Pr, _Alloc, true >::key_compare	key_compare
Public Types inherited from _Tree_buy< _Tmap_traits< _Kty, _Ty, _Pr, _Alloc, true >::value_type, _Tmap_traits< _Kty, _Ty, _Pr, _Alloc, true >::allocator_type >
typedef _Tree_alloc<!is_empty< _Tmap_traits< _Kty, _Ty, _Pr, _Alloc, true >::allocator_type >::value, _Tree_base_types< _Tmap_traits< _Kty, _Ty, _Pr, _Alloc, true >::value_type, _Tmap_traits< _Kty, _Ty, _Pr, _Alloc, true >::allocator_type > >	_Mybase
typedef _Mybase::_Alty	_Alty
typedef _Mybase::_Nodeptr	_Nodeptr
typedef _Mybase::value_type	value_type
Public Types inherited from _Tree_alloc<!is_empty< _Tmap_traits< _Kty, _Ty, _Pr, _Alloc, true >::allocator_type >::value, _Tree_base_types< _Tmap_traits< _Kty, _Ty, _Pr, _Alloc, true >::value_type, _Tmap_traits< _Kty, _Ty, _Pr, _Alloc, true >::allocator_type > >
typedef _Tree_alloc< _Al_has_storage, _Tree_base_types< _Tmap_traits< _Kty, _Ty, _Pr, _Alloc, true >::value_type, _Tmap_traits< _Kty, _Ty, _Pr, _Alloc, true >::allocator_type > >	_Myt
typedef _Tree_base_types< _Tmap_traits< _Kty, _Ty, _Pr, _Alloc, true >::value_type, _Tmap_traits< _Kty, _Ty, _Pr, _Alloc, true >::allocator_type >::_Alloc	_Alloc
typedef _Tree_base_types< _Tmap_traits< _Kty, _Ty, _Pr, _Alloc, true >::value_type, _Tmap_traits< _Kty, _Ty, _Pr, _Alloc, true >::allocator_type >::_Alnod_type	_Alty
typedef _Tree_base_types< _Tmap_traits< _Kty, _Ty, _Pr, _Alloc, true >::value_type, _Tmap_traits< _Kty, _Ty, _Pr, _Alloc, true >::allocator_type >::_Node	_Node
typedef _Tree_base_types< _Tmap_traits< _Kty, _Ty, _Pr, _Alloc, true >::value_type, _Tmap_traits< _Kty, _Ty, _Pr, _Alloc, true >::allocator_type >::_Nodeptr	_Nodeptr
Public Types inherited from _Tree_val< _Tree_base_types< _Tmap_traits< _Kty, _Ty, _Pr, _Alloc, true >::value_type, _Tmap_traits< _Kty, _Ty, _Pr, _Alloc, true >::allocator_type >::_Val_types >
enum	_Redbl
typedef _Tree_val< _Tree_base_types< _Tmap_traits< _Kty, _Ty, _Pr, _Alloc, true >::value_type, _Tmap_traits< _Kty, _Ty, _Pr, _Alloc, true >::allocator_type >::_Val_types >	_Myt
typedef _Tree_base_types< _Tmap_traits< _Kty, _Ty, _Pr, _Alloc, true >::value_type, _Tmap_traits< _Kty, _Ty, _Pr, _Alloc, true >::allocator_type >::_Val_types::_Nodeptr	_Nodeptr
typedef _Nodeptr &	_Nodepref
typedef _Tree_base_types< _Tmap_traits< _Kty, _Ty, _Pr, _Alloc, true >::value_type, _Tmap_traits< _Kty, _Ty, _Pr, _Alloc, true >::allocator_type >::_Val_types::value_type	value_type
typedef _Tree_base_types< _Tmap_traits< _Kty, _Ty, _Pr, _Alloc, true >::value_type, _Tmap_traits< _Kty, _Ty, _Pr, _Alloc, true >::allocator_type >::_Val_types::size_type	size_type
typedef _Tree_base_types< _Tmap_traits< _Kty, _Ty, _Pr, _Alloc, true >::value_type, _Tmap_traits< _Kty, _Ty, _Pr, _Alloc, true >::allocator_type >::_Val_types::difference_type	difference_type
typedef _Tree_base_types< _Tmap_traits< _Kty, _Ty, _Pr, _Alloc, true >::value_type, _Tmap_traits< _Kty, _Ty, _Pr, _Alloc, true >::allocator_type >::_Val_types::pointer	pointer
typedef _Tree_base_types< _Tmap_traits< _Kty, _Ty, _Pr, _Alloc, true >::value_type, _Tmap_traits< _Kty, _Ty, _Pr, _Alloc, true >::allocator_type >::_Val_types::const_pointer	const_pointer
typedef _Tree_base_types< _Tmap_traits< _Kty, _Ty, _Pr, _Alloc, true >::value_type, _Tmap_traits< _Kty, _Ty, _Pr, _Alloc, true >::allocator_type >::_Val_types::reference	reference
typedef _Tree_base_types< _Tmap_traits< _Kty, _Ty, _Pr, _Alloc, true >::value_type, _Tmap_traits< _Kty, _Ty, _Pr, _Alloc, true >::allocator_type >::_Val_types::const_reference	const_reference
typedef _Tree_const_iterator< _Myt >	const_iterator
typedef _Tree_iterator< _Myt >	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)
template<class _Valty >
enable_if< is_convertible< _Valty, value_type >::value, iterator >::type	insert (_Valty &&_Val)
template<class _Valty >
enable_if< is_convertible< _Valty, value_type >::value, iterator >::type	insert (const_iterator _Where, _Valty &&_Val)
template<class... _Valty>
iterator	emplace (_Valty &&..._Val)
void	swap (_Myt &_Right)
	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)
void	insert (_XSTD initializer_list< value_type > _Ilist)
iterator	insert (const value_type &_Val)
iterator	insert (const_iterator _Where, const value_type &_Val)
template<class _Iter >
void	insert (_Iter _First, _Iter _Last)
Public Member Functions inherited from _Tree< _Tmap_traits< _Kty, _Ty, _Pr, _Alloc, true > >
	_Tree (const key_compare &_Parg, const allocator_type &_Al)
	_Tree (const value_type *_First, const value_type *_Last, const key_compare &_Parg, const allocator_type &_Al)
	_Tree (const _Myt &_Right, const allocator_type &_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	insert (value_type &&_Val)
iterator	insert (const_iterator _Where, value_type &&_Val)
enable_if< is_convertible< _Valty, value_type >::value, _Pairib >::type	insert (_Valty &&_Val)
enable_if< is_convertible< _Valty, value_type >::value, iterator >::type	insert (const_iterator _Where, _Valty &&_Val)
_Pairib	insert (const value_type &_Val)
iterator	insert (const_iterator _Where, const value_type &_Val)
void	insert (_Iter _First, _Iter _Last)
void	insert (_XSTD initializer_list< value_type > _Ilist)
_Pairib	emplace (_Valty &&..._Val)
iterator	emplace_hint (const_iterator _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
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
size_type	count (const key_type &_Keyval) const
iterator	lower_bound (const key_type &_Keyval)
const_iterator	lower_bound (const key_type &_Keyval) const
iterator	upper_bound (const key_type &_Keyval)
const_iterator	upper_bound (const key_type &_Keyval) const
_Pairii	equal_range (const key_type &_Keyval)
_Paircc	equal_range (const key_type &_Keyval) const
void	swap (_Myt &_Right)
Public Member Functions inherited from _Tree_comp< !is_empty< _Tmap_traits< _Kty, _Ty, _Pr, _Alloc, true >::key_compare >::value, _Tmap_traits< _Kty, _Ty, _Pr, _Alloc, true > >
	_Tree_comp (const key_compare &_Parg, const allocator_type &_Al)
key_compare &	_Getcomp ()
const key_compare &	_Getcomp () const
void	_Setcomp (const key_compare &_Right)
void	_Swapcomp (key_compare &_Right)
Public Member Functions inherited from _Tree_buy< _Tmap_traits< _Kty, _Ty, _Pr, _Alloc, true >::value_type, _Tmap_traits< _Kty, _Ty, _Pr, _Alloc, true >::allocator_type >
	_Tree_buy (const _Tmap_traits< _Kty, _Ty, _Pr, _Alloc, true >::allocator_type &_Al=_Tmap_traits< _Kty, _Ty, _Pr, _Alloc, true >::allocator_type())
_Nodeptr	_Buynode0 ()
void	_Freenode0 (_Nodeptr _Pnode)
_Nodeptr	_Buynode (_Valty &&..._Val)
Public Member Functions inherited from _Tree_alloc<!is_empty< _Tmap_traits< _Kty, _Ty, _Pr, _Alloc, true >::allocator_type >::value, _Tree_base_types< _Tmap_traits< _Kty, _Ty, _Pr, _Alloc, true >::value_type, _Tmap_traits< _Kty, _Ty, _Pr, _Alloc, true >::allocator_type > >
	_Tree_alloc (const _Alloc &_Al=_Alloc())
	~_Tree_alloc () _NOEXCEPT
void	_Change_alloc (const _Alty &_Al)
void	_Swap_alloc (_Myt &_Right)
_Nodeptr	_Buyheadnode ()
void	_Freeheadnode (_Nodeptr _Pnode)
_Alty &	_Getal ()
const _Alty &	_Getal () const
Public Member Functions inherited from _Tree_val< _Tree_base_types< _Tmap_traits< _Kty, _Ty, _Pr, _Alloc, true >::value_type, _Tmap_traits< _Kty, _Ty, _Pr, _Alloc, true >::allocator_type >::_Val_types >
	_Tree_val ()
Public Member Functions inherited from _Container_base0
void	_Orphan_all ()
void	_Swap_all (_Container_base0 &)

Additional Inherited Members
Static Public Member Functions inherited from _Tree_val< _Tree_base_types< _Tmap_traits< _Kty, _Ty, _Pr, _Alloc, true >::value_type, _Tmap_traits< _Kty, _Ty, _Pr, _Alloc, true >::allocator_type >::_Val_types >
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)
Public Attributes inherited from _Tree_comp< !is_empty< _Tmap_traits< _Kty, _Ty, _Pr, _Alloc, true >::key_compare >::value, _Tmap_traits< _Kty, _Ty, _Pr, _Alloc, true > >
key_compare	comp
Public Attributes inherited from _Tree_alloc<!is_empty< _Tmap_traits< _Kty, _Ty, _Pr, _Alloc, true >::allocator_type >::value, _Tree_base_types< _Tmap_traits< _Kty, _Ty, _Pr, _Alloc, true >::value_type, _Tmap_traits< _Kty, _Ty, _Pr, _Alloc, true >::allocator_type > >
_Tree_base_types< _Tmap_traits< _Kty, _Ty, _Pr, _Alloc, true >::value_type, _Tmap_traits< _Kty, _Ty, _Pr, _Alloc, true >::allocator_type >::_Alnod_type	_Alnod
Public Attributes inherited from _Tree_val< _Tree_base_types< _Tmap_traits< _Kty, _Ty, _Pr, _Alloc, true >::value_type, _Tmap_traits< _Kty, _Ty, _Pr, _Alloc, true >::allocator_type >::_Val_types >
_Nodeptr	_Myhead
size_type	_Mysize
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 (_Nodeptr _Rootnode, _Want_to_move, _Can_move, _Is_set, _Dummy)
_Nodeptr	_Copy_or_move (_Nodeptr _Rootnode, true_type, true_type, true_type, _Dummy)
_Nodeptr	_Copy_or_move (_Nodeptr _Rootnode, true_type, true_type, false_type, _Dummy)
_Nodeptr	_Copy_nodes (_Nodeptr _Rootnode, _Nodeptr _Wherenode, _Moveit _Movefl)
_Paircc	_Eqrange (const key_type &_Keyval) const
_Pairii	_Eqrange (const key_type &_Keyval)
void	_Erase (_Nodeptr _Rootnode)
_Nodeptr	_Lbound (const key_type &_Keyval) const
_Nodeptr	_Lbound (const key_type &_Keyval)
_Nodeptr &	_Lmost () const
void	_Lrotate (_Nodeptr _Wherenode)
_Nodeptr &	_Rmost () const
_Nodeptr &	_Root () const
void	_Rrotate (_Nodeptr _Wherenode)
_Nodeptr	_Ubound (const key_type &_Keyval) const
_Nodeptr	_Ubound (const key_type &_Keyval)
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 _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 _Ty multimap< _Kty, _Ty, _Pr, _Alloc >::referent_type

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(), allocator_type())
        {   // 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, allocator_type())
        {   // 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(), allocator_type())
        {   // construct map from [_First, _Last), defaults
        _Mybase::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, allocator_type())
        {   // construct map from [_First, _Last), comparator
        _Mybase::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
        _Mybase::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(), allocator_type())
        {   // construct from initializer_list, defaults
        this->insert(_Ilist.begin(), _Ilist.end());
        }

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, allocator_type())
        {   // construct from initializer_list, comparator
        this->insert(_Ilist.begin(), _Ilist.end());
        }

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
        this->insert(_Ilist.begin(), _Ilist.end());
        }

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 >

enable_if<is_convertible<_Valty, value_type>::value, iterator>::type multimap< _Kty, _Ty, _Pr, _Alloc >::insert ( _Valty &&  _Val )

inline

        {   // insert a {key, mapped} value
        return (_Mybase::insert(_STD forward<_Valty>(_Val)).first);
        }

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

template<class _Valty >

enable_if<is_convertible<_Valty, value_type>::value, iterator>::type multimap< _Kty, _Ty, _Pr, _Alloc >::insert ( const_iterator  _Where, _Valty &&  _Val  )

inline

        {   // insert a {key, mapped} value, with hint
        return (_Mybase::insert(_Where, _STD forward<_Valty>(_Val)));
        }

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

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

inline

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

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

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

inline

        {   // insert a {key, mapped} value
        return (_Mybase::insert(_Val).first);
        }

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

iterator multimap< _Kty, _Ty, _Pr, _Alloc >::insert ( const_iterator  _Where, const value_type &  _Val  )

inline

        {   // insert a {key, mapped} value, with hint
        return (_Mybase::insert(_Where, _Val));
        }

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

template<class _Iter >

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

inline

        {   // insert [_First, _Last), arbitrary iterators
        _Mybase::insert(_First, _Last);
        }

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
        this->clear();
        this->insert(_Ilist.begin(), _Ilist.end());
        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:

• VS2013/inc/map