.TH "std::multimap< _Key, _Tp, _Compare, _Alloc >" 3cxx "libstdc++" \" -*- nroff -*-
.ad l
.nh
.SH NAME
std::multimap< _Key, _Tp, _Compare, _Alloc > \- A standard container made up of (key,value) pairs, which can be retrieved based on a key, in logarithmic time\&.  

.SH SYNOPSIS
.br
.PP
.PP
\fC#include <stl_multimap\&.h>\fP
.SS "Public Types"

.in +1c
.ti -1c
.RI "\fBtypedef\fP _Alloc \fBallocator_type\fP"
.br
.ti -1c
.RI "\fBtypedef\fP \fB_Rep_type::const_iterator\fP \fBconst_iterator\fP"
.br
.ti -1c
.RI "\fBtypedef\fP _Alloc_traits::const_pointer \fBconst_pointer\fP"
.br
.ti -1c
.RI "\fBtypedef\fP _Alloc_traits::const_reference \fBconst_reference\fP"
.br
.ti -1c
.RI "\fBtypedef\fP \fB_Rep_type::const_reverse_iterator\fP \fBconst_reverse_iterator\fP"
.br
.ti -1c
.RI "\fBtypedef\fP \fB_Rep_type::difference_type\fP \fBdifference_type\fP"
.br
.ti -1c
.RI "\fBtypedef\fP \fB_Rep_type::iterator\fP \fBiterator\fP"
.br
.ti -1c
.RI "\fBtypedef\fP _Compare \fBkey_compare\fP"
.br
.ti -1c
.RI "\fBtypedef\fP \fB_Key\fP \fBkey_type\fP"
.br
.ti -1c
.RI "\fBtypedef\fP _Tp \fBmapped_type\fP"
.br
.ti -1c
.RI "\fBusing\fP \fBnode_type\fP = \fBtypename\fP \fB_Rep_type::node_type\fP"
.br
.ti -1c
.RI "\fBtypedef\fP \fB_Alloc_traits::pointer\fP \fBpointer\fP"
.br
.ti -1c
.RI "\fBtypedef\fP _Alloc_traits::reference \fBreference\fP"
.br
.ti -1c
.RI "\fBtypedef\fP \fB_Rep_type::reverse_iterator\fP \fBreverse_iterator\fP"
.br
.ti -1c
.RI "\fBtypedef\fP _Rep_type::size_type \fBsize_type\fP"
.br
.ti -1c
.RI "\fBtypedef\fP \fBstd::pair\fP< \fBconst\fP \fB_Key\fP, _Tp > \fBvalue_type\fP"
.br
.in -1c
.SS "Public Member Functions"

.in +1c
.ti -1c
.RI "\fBmultimap\fP ()=\fBdefault\fP"
.br
.RI "Default constructor creates no elements\&. "
.ti -1c
.RI "template<\fBtypename\fP \fB_InputIterator\fP > \fBmultimap\fP (\fB_InputIterator\fP __first, \fB_InputIterator\fP __last)"
.br
.RI "Builds a multimap from a range\&. "
.ti -1c
.RI "template<\fBtypename\fP \fB_InputIterator\fP > \fBmultimap\fP (\fB_InputIterator\fP __first, \fB_InputIterator\fP __last, \fBconst\fP _Compare &__comp, \fBconst\fP allocator_type &__a=allocator_type())"
.br
.RI "Builds a multimap from a range\&. "
.ti -1c
.RI "template<\fBtypename\fP \fB_InputIterator\fP > \fBmultimap\fP (\fB_InputIterator\fP __first, \fB_InputIterator\fP __last, \fBconst\fP allocator_type &__a)"
.br
.RI "Allocator-extended range constructor\&. "
.ti -1c
.RI "\fBmultimap\fP (\fBconst\fP _Compare &__comp, \fBconst\fP allocator_type &__a=allocator_type())"
.br
.RI "Creates a multimap with no elements\&. "
.ti -1c
.RI "\fBmultimap\fP (\fBconst\fP allocator_type &__a)"
.br
.RI "Allocator-extended default constructor\&. "
.ti -1c
.RI "\fBmultimap\fP (\fBconst\fP \fBmultimap\fP &)=\fBdefault\fP"
.br
.RI "Multimap copy constructor\&. "
.ti -1c
.RI "\fBmultimap\fP (\fBconst\fP \fBmultimap\fP &\fB__m\fP, \fBconst\fP allocator_type &__a)"
.br
.RI "Allocator-extended copy constructor\&. "
.ti -1c
.RI "\fBmultimap\fP (\fBinitializer_list\fP< \fBvalue_type\fP > \fB__l\fP, \fBconst\fP _Compare &__comp=_Compare(), \fBconst\fP allocator_type &__a=allocator_type())"
.br
.RI "Builds a multimap from an initializer_list\&. "
.ti -1c
.RI "\fBmultimap\fP (\fBinitializer_list\fP< \fBvalue_type\fP > \fB__l\fP, \fBconst\fP allocator_type &__a)"
.br
.RI "Allocator-extended initialier-list constructor\&. "
.ti -1c
.RI "\fBmultimap\fP (\fBmultimap\fP &&)=\fBdefault\fP"
.br
.RI "Multimap move constructor\&. "
.ti -1c
.RI "\fBmultimap\fP (\fBmultimap\fP &&\fB__m\fP, \fBconst\fP allocator_type &__a) \fBnoexcept\fP(\fBis_nothrow_copy_constructible\fP< _Compare >::value &&_Alloc_traits::_S_always_equal())"
.br
.RI "Allocator-extended move constructor\&. "
.ti -1c
.RI "\fB~multimap\fP ()=\fBdefault\fP"
.br
.ti -1c
.RI "\fBconst_iterator\fP \fBbegin\fP () \fBconst\fP \fBnoexcept\fP"
.br
.ti -1c
.RI "\fBiterator\fP \fBbegin\fP () \fBnoexcept\fP"
.br
.ti -1c
.RI "\fBconst_iterator\fP \fBcbegin\fP () \fBconst\fP \fBnoexcept\fP"
.br
.ti -1c
.RI "\fBconst_iterator\fP \fBcend\fP () \fBconst\fP \fBnoexcept\fP"
.br
.ti -1c
.RI "\fBvoid\fP \fBclear\fP () \fBnoexcept\fP"
.br
.ti -1c
.RI "\fBconst_reverse_iterator\fP \fBcrbegin\fP () \fBconst\fP \fBnoexcept\fP"
.br
.ti -1c
.RI "\fBconst_reverse_iterator\fP \fBcrend\fP () \fBconst\fP \fBnoexcept\fP"
.br
.ti -1c
.RI "template<typename\&.\&.\&. _Args> \fBiterator\fP \fBemplace\fP (\fB_Args\fP &&\&.\&.\&. \fB__args\fP)"
.br
.RI "Build and insert a std::pair into the multimap\&. "
.ti -1c
.RI "template<typename\&.\&.\&. _Args> \fBiterator\fP \fBemplace_hint\fP (\fBconst_iterator\fP \fB__pos\fP, \fB_Args\fP &&\&.\&.\&. \fB__args\fP)"
.br
.RI "Builds and inserts a std::pair into the multimap\&. "
.ti -1c
.RI "bool \fBempty\fP () \fBconst\fP \fBnoexcept\fP"
.br
.ti -1c
.RI "\fBconst_iterator\fP \fBend\fP () \fBconst\fP \fBnoexcept\fP"
.br
.ti -1c
.RI "\fBiterator\fP \fBend\fP () \fBnoexcept\fP"
.br
.ti -1c
.RI "size_type \fBerase\fP (\fBconst\fP \fBkey_type\fP &__x)"
.br
.RI "Erases elements according to the provided key\&. "
.ti -1c
.RI "\fBiterator\fP \fBerase\fP (\fBconst_iterator\fP __first, \fBconst_iterator\fP __last)"
.br
.RI "Erases a [first,last) range of elements from a multimap\&. "
.ti -1c
.RI "node_type \fBextract\fP (\fBconst\fP \fBkey_type\fP &__x)"
.br
.RI "Extract a node\&. "
.ti -1c
.RI "node_type \fBextract\fP (\fBconst_iterator\fP \fB__pos\fP)"
.br
.RI "Extract a node\&. "
.ti -1c
.RI "allocator_type \fBget_allocator\fP () \fBconst\fP \fBnoexcept\fP"
.br
.RI "Get a copy of the memory allocation object\&. "
.ti -1c
.RI "template<\fBtypename\fP \fB_InputIterator\fP > \fBvoid\fP \fBinsert\fP (\fB_InputIterator\fP __first, \fB_InputIterator\fP __last)"
.br
.RI "A template function that attempts to insert a range of elements\&. "
.ti -1c
.RI "\fBiterator\fP \fBinsert\fP (\fBconst_iterator\fP \fB__hint\fP, node_type &&\fB__nh\fP)"
.br
.RI "Re-insert an extracted node\&. "
.ti -1c
.RI "\fBvoid\fP \fBinsert\fP (\fBinitializer_list\fP< \fBvalue_type\fP > \fB__l\fP)"
.br
.RI "Attempts to insert a list of std::pairs into the multimap\&. "
.ti -1c
.RI "\fBiterator\fP \fBinsert\fP (node_type &&\fB__nh\fP)"
.br
.RI "Re-insert an extracted node\&. "
.ti -1c
.RI "key_compare \fBkey_comp\fP () \fBconst\fP"
.br
.ti -1c
.RI "size_type \fBmax_size\fP () \fBconst\fP \fBnoexcept\fP"
.br
.ti -1c
.RI "template<\fBtypename\fP \fB_Cmp2\fP > \fBvoid\fP \fBmerge\fP (\fBmap\fP< \fB_Key\fP, _Tp, \fB_Cmp2\fP, _Alloc > &&\fB__source\fP)"
.br
.ti -1c
.RI "template<\fBtypename\fP \fB_Cmp2\fP > \fBvoid\fP \fBmerge\fP (\fBmap\fP< \fB_Key\fP, _Tp, \fB_Cmp2\fP, _Alloc > &\fB__source\fP)"
.br
.ti -1c
.RI "template<\fBtypename\fP \fB_Cmp2\fP > \fBvoid\fP \fBmerge\fP (\fBmultimap\fP< \fB_Key\fP, _Tp, \fB_Cmp2\fP, _Alloc > &&\fB__source\fP)"
.br
.ti -1c
.RI "template<\fBtypename\fP \fB_Cmp2\fP > \fBvoid\fP \fBmerge\fP (\fBmultimap\fP< \fB_Key\fP, _Tp, \fB_Cmp2\fP, _Alloc > &\fB__source\fP)"
.br
.ti -1c
.RI "\fBmultimap\fP & \fBoperator=\fP (\fBconst\fP \fBmultimap\fP &)=\fBdefault\fP"
.br
.RI "Multimap assignment operator\&. "
.ti -1c
.RI "\fBmultimap\fP & \fBoperator=\fP (\fBinitializer_list\fP< \fBvalue_type\fP > \fB__l\fP)"
.br
.RI "Multimap list assignment operator\&. "
.ti -1c
.RI "\fBmultimap\fP & \fBoperator=\fP (\fBmultimap\fP &&)=\fBdefault\fP"
.br
.RI "Move assignment operator\&. "
.ti -1c
.RI "\fBconst_reverse_iterator\fP \fBrbegin\fP () \fBconst\fP \fBnoexcept\fP"
.br
.ti -1c
.RI "\fBreverse_iterator\fP \fBrbegin\fP () \fBnoexcept\fP"
.br
.ti -1c
.RI "\fBconst_reverse_iterator\fP \fBrend\fP () \fBconst\fP \fBnoexcept\fP"
.br
.ti -1c
.RI "\fBreverse_iterator\fP \fBrend\fP () \fBnoexcept\fP"
.br
.ti -1c
.RI "size_type \fBsize\fP () \fBconst\fP \fBnoexcept\fP"
.br
.ti -1c
.RI "\fBvoid\fP \fBswap\fP (\fBmultimap\fP &__x) \fBnoexcept\fP(/*\fBconditional\fP */)"
.br
.RI "Swaps data with another multimap\&. "
.ti -1c
.RI "value_compare \fBvalue_comp\fP () \fBconst\fP"
.br
.in -1c
.PP
.RI "\fB\fP"
.br

.in +1c
.in +1c
.ti -1c
.RI "\fBiterator\fP \fBinsert\fP (\fBconst\fP \fBvalue_type\fP &__x)"
.br
.RI "Inserts a std::pair into the multimap\&. "
.ti -1c
.RI "\fBiterator\fP \fBinsert\fP (\fBvalue_type\fP &&__x)"
.br
.RI "Inserts a std::pair into the multimap\&. "
.ti -1c
.RI "template<\fBtypename\fP \fB_Pair\fP > \fB__enable_if_t\fP< \fBis_constructible\fP< \fBvalue_type\fP, \fB_Pair\fP >::value, \fBiterator\fP > \fBinsert\fP (\fB_Pair\fP &&__x)"
.br
.RI "Inserts a std::pair into the multimap\&. "
.in -1c
.in -1c
.PP
.RI "\fB\fP"
.br

.in +1c
.in +1c
.ti -1c
.RI "\fBiterator\fP \fBinsert\fP (\fBconst_iterator\fP \fB__position\fP, \fBconst\fP \fBvalue_type\fP &__x)"
.br
.RI "Inserts a std::pair into the multimap\&. "
.ti -1c
.RI "\fBiterator\fP \fBinsert\fP (\fBconst_iterator\fP \fB__position\fP, \fBvalue_type\fP &&__x)"
.br
.RI "Inserts a std::pair into the multimap\&. "
.ti -1c
.RI "template<\fBtypename\fP \fB_Pair\fP > \fB__enable_if_t\fP< \fBis_constructible\fP< \fBvalue_type\fP, \fB_Pair\fP && >::value, \fBiterator\fP > \fBinsert\fP (\fBconst_iterator\fP \fB__position\fP, \fB_Pair\fP &&__x)"
.br
.RI "Inserts a std::pair into the multimap\&. "
.in -1c
.in -1c
.PP
.RI "\fB\fP"
.br

.in +1c
.in +1c
.ti -1c
.RI "\fBiterator\fP \fBerase\fP (\fBconst_iterator\fP \fB__position\fP)"
.br
.RI "Erases an element from a multimap\&. "
.ti -1c
.RI "_GLIBCXX_ABI_TAG_CXX11 \fBiterator\fP \fBerase\fP (\fBiterator\fP \fB__position\fP)"
.br
.RI "Erases an element from a multimap\&. "
.in -1c
.in -1c
.PP
.RI "\fB\fP"
.br

.in +1c
.in +1c
.ti -1c
.RI "\fBiterator\fP \fBfind\fP (\fBconst\fP \fBkey_type\fP &__x)"
.br
.RI "Tries to locate an element in a multimap\&. "
.ti -1c
.RI "template<\fBtypename\fP \fB_Kt\fP > \fBauto\fP \fBfind\fP (\fBconst\fP \fB_Kt\fP &__x) \-> \fBdecltype\fP(_M_t\&._M_find_tr(__x))"
.br
.RI "Tries to locate an element in a multimap\&. "
.in -1c
.in -1c
.PP
.RI "\fB\fP"
.br

.in +1c
.in +1c
.ti -1c
.RI "\fBconst_iterator\fP \fBfind\fP (\fBconst\fP \fBkey_type\fP &__x) \fBconst\fP"
.br
.RI "Tries to locate an element in a multimap\&. "
.ti -1c
.RI "template<\fBtypename\fP \fB_Kt\fP > \fBauto\fP \fBfind\fP (\fBconst\fP \fB_Kt\fP &__x) \fBconst\fP \-> \fBdecltype\fP(_M_t\&._M_find_tr(__x))"
.br
.RI "Tries to locate an element in a multimap\&. "
.in -1c
.in -1c
.PP
.RI "\fB\fP"
.br

.in +1c
.in +1c
.ti -1c
.RI "size_type \fBcount\fP (\fBconst\fP \fBkey_type\fP &__x) \fBconst\fP"
.br
.RI "Finds the number of elements with given key\&. "
.ti -1c
.RI "template<\fBtypename\fP \fB_Kt\fP > \fBauto\fP \fBcount\fP (\fBconst\fP \fB_Kt\fP &__x) \fBconst\fP \-> \fBdecltype\fP(_M_t\&._M_count_tr(__x))"
.br
.RI "Finds the number of elements with given key\&. "
.in -1c
.in -1c
.PP
.RI "\fB\fP"
.br

.in +1c
.in +1c
.ti -1c
.RI "\fBiterator\fP \fBlower_bound\fP (\fBconst\fP \fBkey_type\fP &__x)"
.br
.RI "Finds the beginning of a subsequence matching given key\&. "
.ti -1c
.RI "template<\fBtypename\fP \fB_Kt\fP > \fBauto\fP \fBlower_bound\fP (\fBconst\fP \fB_Kt\fP &__x) \-> \fBdecltype\fP(\fBiterator\fP(_M_t\&._M_lower_bound_tr(__x)))"
.br
.RI "Finds the beginning of a subsequence matching given key\&. "
.in -1c
.in -1c
.PP
.RI "\fB\fP"
.br

.in +1c
.in +1c
.ti -1c
.RI "\fBconst_iterator\fP \fBlower_bound\fP (\fBconst\fP \fBkey_type\fP &__x) \fBconst\fP"
.br
.RI "Finds the beginning of a subsequence matching given key\&. "
.ti -1c
.RI "template<\fBtypename\fP \fB_Kt\fP > \fBauto\fP \fBlower_bound\fP (\fBconst\fP \fB_Kt\fP &__x) \fBconst\fP \-> \fBdecltype\fP(\fBconst_iterator\fP(_M_t\&._M_lower_bound_tr(__x)))"
.br
.RI "Finds the beginning of a subsequence matching given key\&. "
.in -1c
.in -1c
.PP
.RI "\fB\fP"
.br

.in +1c
.in +1c
.ti -1c
.RI "\fBiterator\fP \fBupper_bound\fP (\fBconst\fP \fBkey_type\fP &__x)"
.br
.RI "Finds the end of a subsequence matching given key\&. "
.ti -1c
.RI "template<\fBtypename\fP \fB_Kt\fP > \fBauto\fP \fBupper_bound\fP (\fBconst\fP \fB_Kt\fP &__x) \-> \fBdecltype\fP(\fBiterator\fP(_M_t\&._M_upper_bound_tr(__x)))"
.br
.RI "Finds the end of a subsequence matching given key\&. "
.in -1c
.in -1c
.PP
.RI "\fB\fP"
.br

.in +1c
.in +1c
.ti -1c
.RI "\fBconst_iterator\fP \fBupper_bound\fP (\fBconst\fP \fBkey_type\fP &__x) \fBconst\fP"
.br
.RI "Finds the end of a subsequence matching given key\&. "
.ti -1c
.RI "template<\fBtypename\fP \fB_Kt\fP > \fBauto\fP \fBupper_bound\fP (\fBconst\fP \fB_Kt\fP &__x) \fBconst\fP \-> \fBdecltype\fP(\fBconst_iterator\fP(_M_t\&._M_upper_bound_tr(__x)))"
.br
.RI "Finds the end of a subsequence matching given key\&. "
.in -1c
.in -1c
.PP
.RI "\fB\fP"
.br

.in +1c
.in +1c
.ti -1c
.RI "\fBstd::pair\fP< \fBiterator\fP, \fBiterator\fP > \fBequal_range\fP (\fBconst\fP \fBkey_type\fP &__x)"
.br
.RI "Finds a subsequence matching given key\&. "
.ti -1c
.RI "template<\fBtypename\fP \fB_Kt\fP > \fBauto\fP \fBequal_range\fP (\fBconst\fP \fB_Kt\fP &__x) \-> \fBdecltype\fP(\fBpair\fP< \fBiterator\fP, \fBiterator\fP >(_M_t\&._M_equal_range_tr(__x)))"
.br
.RI "Finds a subsequence matching given key\&. "
.in -1c
.in -1c
.PP
.RI "\fB\fP"
.br

.in +1c
.in +1c
.ti -1c
.RI "\fBstd::pair\fP< \fBconst_iterator\fP, \fBconst_iterator\fP > \fBequal_range\fP (\fBconst\fP \fBkey_type\fP &__x) \fBconst\fP"
.br
.RI "Finds a subsequence matching given key\&. "
.ti -1c
.RI "template<\fBtypename\fP \fB_Kt\fP > \fBauto\fP \fBequal_range\fP (\fBconst\fP \fB_Kt\fP &__x) \fBconst\fP \-> \fBdecltype\fP(\fBpair\fP< \fBconst_iterator\fP, \fBconst_iterator\fP >(_M_t\&._M_equal_range_tr(__x)))"
.br
.RI "Finds a subsequence matching given key\&. "
.in -1c
.in -1c
.SS "Friends"

.in +1c
.ti -1c
.RI "template<\fBtypename\fP \fB_K1\fP , \fBtypename\fP _T1 , \fBtypename\fP \fB_C1\fP , \fBtypename\fP \fB_A1\fP > bool \fBoperator<\fP (\fBconst\fP \fBmultimap\fP< \fB_K1\fP, _T1, \fB_C1\fP, \fB_A1\fP > &, \fBconst\fP \fBmultimap\fP< \fB_K1\fP, _T1, \fB_C1\fP, \fB_A1\fP > &)"
.br
.ti -1c
.RI "template<\fBtypename\fP \fB_K1\fP , \fBtypename\fP _T1 , \fBtypename\fP \fB_C1\fP , \fBtypename\fP \fB_A1\fP > bool \fBoperator==\fP (\fBconst\fP \fBmultimap\fP< \fB_K1\fP, _T1, \fB_C1\fP, \fB_A1\fP > &, \fBconst\fP \fBmultimap\fP< \fB_K1\fP, _T1, \fB_C1\fP, \fB_A1\fP > &)"
.br
.ti -1c
.RI "template<\fBtypename\fP , \fBtypename\fP > \fBstruct\fP \fBstd::_Rb_tree_merge_helper\fP"
.br
.in -1c
.SH "Detailed Description"
.PP 

.SS "template<\fBtypename\fP \fB_Key\fP, \fBtypename\fP _Tp, \fBtypename\fP _Compare = std::less<_Key>, \fBtypename\fP _Alloc = std::allocator<std::pair<const _Key, _Tp> >>
.br
class std::multimap< _Key, _Tp, _Compare, _Alloc >"A standard container made up of (key,value) pairs, which can be retrieved based on a key, in logarithmic time\&. 


.PP
\fBTemplate Parameters\fP
.RS 4
\fI_Key\fP Type of key objects\&. 
.br
\fI_Tp\fP Type of mapped objects\&. 
.br
\fI_Compare\fP Comparison function object type, defaults to less<_Key>\&. 
.br
\fI_Alloc\fP Allocator type, defaults to allocator<pair<const _Key, _Tp>\&.
.RE
.PP
Meets the requirements of a \fCcontainer\fP, a \fCreversible container\fP, and an \fCassociative container\fP (using equivalent keys)\&. For a \fCmultimap<Key,T>\fP the key_type is Key, the mapped_type is T, and the value_type is std::pair<const Key,T>\&.
.PP
Multimaps support bidirectional iterators\&.
.PP
The private tree data is declared exactly the same way for map and multimap; the distinction is made entirely in how the tree functions are called (*_unique versus *_equal, same as the standard)\&. 
.SH "Constructor & Destructor Documentation"
.PP 
.SS "template<\fBtypename\fP \fB_Key\fP , \fBtypename\fP _Tp , \fBtypename\fP _Compare  = std::less<_Key>, \fBtypename\fP _Alloc  = std::allocator<std::pair<const _Key, _Tp> >> \fBstd::multimap\fP< \fB_Key\fP, _Tp, _Compare, _Alloc >::multimap ()\fC [default]\fP"

.PP
Default constructor creates no elements\&. 
.SS "template<\fBtypename\fP \fB_Key\fP , \fBtypename\fP _Tp , \fBtypename\fP _Compare  = std::less<_Key>, \fBtypename\fP _Alloc  = std::allocator<std::pair<const _Key, _Tp> >> \fBstd::multimap\fP< \fB_Key\fP, _Tp, _Compare, _Alloc >::multimap (\fBconst\fP _Compare & __comp, \fBconst\fP allocator_type & __a = \fCallocator_type()\fP)\fC [inline]\fP, \fC [explicit]\fP"

.PP
Creates a multimap with no elements\&. 
.PP
\fBParameters\fP
.RS 4
\fI__comp\fP A comparison object\&. 
.br
\fI__a\fP An allocator object\&. 
.RE
.PP

.SS "template<\fBtypename\fP \fB_Key\fP , \fBtypename\fP _Tp , \fBtypename\fP _Compare  = std::less<_Key>, \fBtypename\fP _Alloc  = std::allocator<std::pair<const _Key, _Tp> >> \fBstd::multimap\fP< \fB_Key\fP, _Tp, _Compare, _Alloc >::multimap (\fBconst\fP \fBmultimap\fP< \fB_Key\fP, _Tp, _Compare, _Alloc > &)\fC [default]\fP"

.PP
Multimap copy constructor\&. Whether the allocator is copied depends on the allocator traits\&. 
.SS "template<\fBtypename\fP \fB_Key\fP , \fBtypename\fP _Tp , \fBtypename\fP _Compare  = std::less<_Key>, \fBtypename\fP _Alloc  = std::allocator<std::pair<const _Key, _Tp> >> \fBstd::multimap\fP< \fB_Key\fP, _Tp, _Compare, _Alloc >::multimap (\fBmultimap\fP< \fB_Key\fP, _Tp, _Compare, _Alloc > &&)\fC [default]\fP"

.PP
Multimap move constructor\&. The newly-created multimap contains the exact contents of the moved instance\&. The moved instance is a valid, but unspecified multimap\&. 
.SS "template<\fBtypename\fP \fB_Key\fP , \fBtypename\fP _Tp , \fBtypename\fP _Compare  = std::less<_Key>, \fBtypename\fP _Alloc  = std::allocator<std::pair<const _Key, _Tp> >> \fBstd::multimap\fP< \fB_Key\fP, _Tp, _Compare, _Alloc >::multimap (\fBinitializer_list\fP< \fBvalue_type\fP > __l, \fBconst\fP _Compare & __comp = \fC_Compare()\fP, \fBconst\fP allocator_type & __a = \fCallocator_type()\fP)\fC [inline]\fP"

.PP
Builds a multimap from an initializer_list\&. 
.PP
\fBParameters\fP
.RS 4
\fI__l\fP An initializer_list\&. 
.br
\fI__comp\fP A comparison functor\&. 
.br
\fI__a\fP An allocator object\&.
.RE
.PP
Create a multimap consisting of copies of the elements from the initializer_list\&. This is linear in N if the list is already sorted, and NlogN otherwise (where N is \fI__l\&.size()\fP)\&. 
.SS "template<\fBtypename\fP \fB_Key\fP , \fBtypename\fP _Tp , \fBtypename\fP _Compare  = std::less<_Key>, \fBtypename\fP _Alloc  = std::allocator<std::pair<const _Key, _Tp> >> \fBstd::multimap\fP< \fB_Key\fP, _Tp, _Compare, _Alloc >::multimap (\fBconst\fP allocator_type & __a)\fC [inline]\fP, \fC [explicit]\fP"

.PP
Allocator-extended default constructor\&. 
.SS "template<\fBtypename\fP \fB_Key\fP , \fBtypename\fP _Tp , \fBtypename\fP _Compare  = std::less<_Key>, \fBtypename\fP _Alloc  = std::allocator<std::pair<const _Key, _Tp> >> \fBstd::multimap\fP< \fB_Key\fP, _Tp, _Compare, _Alloc >::multimap (\fBconst\fP \fBmultimap\fP< \fB_Key\fP, _Tp, _Compare, _Alloc > & __m, \fBconst\fP allocator_type & __a)\fC [inline]\fP"

.PP
Allocator-extended copy constructor\&. 
.SS "template<\fBtypename\fP \fB_Key\fP , \fBtypename\fP _Tp , \fBtypename\fP _Compare  = std::less<_Key>, \fBtypename\fP _Alloc  = std::allocator<std::pair<const _Key, _Tp> >> \fBstd::multimap\fP< \fB_Key\fP, _Tp, _Compare, _Alloc >::multimap (\fBmultimap\fP< \fB_Key\fP, _Tp, _Compare, _Alloc > && __m, \fBconst\fP allocator_type & __a)\fC [inline]\fP, \fC [noexcept]\fP"

.PP
Allocator-extended move constructor\&. 
.SS "template<\fBtypename\fP \fB_Key\fP , \fBtypename\fP _Tp , \fBtypename\fP _Compare  = std::less<_Key>, \fBtypename\fP _Alloc  = std::allocator<std::pair<const _Key, _Tp> >> \fBstd::multimap\fP< \fB_Key\fP, _Tp, _Compare, _Alloc >::multimap (\fBinitializer_list\fP< \fBvalue_type\fP > __l, \fBconst\fP allocator_type & __a)\fC [inline]\fP"

.PP
Allocator-extended initialier-list constructor\&. 
.SS "template<\fBtypename\fP \fB_Key\fP , \fBtypename\fP _Tp , \fBtypename\fP _Compare  = std::less<_Key>, \fBtypename\fP _Alloc  = std::allocator<std::pair<const _Key, _Tp> >> template<\fBtypename\fP \fB_InputIterator\fP > \fBstd::multimap\fP< \fB_Key\fP, _Tp, _Compare, _Alloc >::multimap (\fB_InputIterator\fP __first, \fB_InputIterator\fP __last, \fBconst\fP allocator_type & __a)\fC [inline]\fP"

.PP
Allocator-extended range constructor\&. 
.SS "template<\fBtypename\fP \fB_Key\fP , \fBtypename\fP _Tp , \fBtypename\fP _Compare  = std::less<_Key>, \fBtypename\fP _Alloc  = std::allocator<std::pair<const _Key, _Tp> >> template<\fBtypename\fP \fB_InputIterator\fP > \fBstd::multimap\fP< \fB_Key\fP, _Tp, _Compare, _Alloc >::multimap (\fB_InputIterator\fP __first, \fB_InputIterator\fP __last)\fC [inline]\fP"

.PP
Builds a multimap from a range\&. 
.PP
\fBParameters\fP
.RS 4
\fI__first\fP An input iterator\&. 
.br
\fI__last\fP An input iterator\&.
.RE
.PP
Create a multimap consisting of copies of the elements from [__first,__last)\&. This is linear in N if the range is already sorted, and NlogN otherwise (where N is distance(__first,__last))\&. 
.SS "template<\fBtypename\fP \fB_Key\fP , \fBtypename\fP _Tp , \fBtypename\fP _Compare  = std::less<_Key>, \fBtypename\fP _Alloc  = std::allocator<std::pair<const _Key, _Tp> >> template<\fBtypename\fP \fB_InputIterator\fP > \fBstd::multimap\fP< \fB_Key\fP, _Tp, _Compare, _Alloc >::multimap (\fB_InputIterator\fP __first, \fB_InputIterator\fP __last, \fBconst\fP _Compare & __comp, \fBconst\fP allocator_type & __a = \fCallocator_type()\fP)\fC [inline]\fP"

.PP
Builds a multimap from a range\&. 
.PP
\fBParameters\fP
.RS 4
\fI__first\fP An input iterator\&. 
.br
\fI__last\fP An input iterator\&. 
.br
\fI__comp\fP A comparison functor\&. 
.br
\fI__a\fP An allocator object\&.
.RE
.PP
Create a multimap consisting of copies of the elements from [__first,__last)\&. This is linear in N if the range is already sorted, and NlogN otherwise (where N is distance(__first,__last))\&. 
.SS "template<\fBtypename\fP \fB_Key\fP , \fBtypename\fP _Tp , \fBtypename\fP _Compare  = std::less<_Key>, \fBtypename\fP _Alloc  = std::allocator<std::pair<const _Key, _Tp> >> \fBstd::multimap\fP< \fB_Key\fP, _Tp, _Compare, _Alloc >::~\fBmultimap\fP ()\fC [default]\fP"
The dtor only erases the elements, and note that if the elements themselves are pointers, the pointed-to memory is not touched in any way\&. Managing the pointer is the user's responsibility\&. 
.SH "Member Function Documentation"
.PP 
.SS "template<\fBtypename\fP \fB_Key\fP , \fBtypename\fP _Tp , \fBtypename\fP _Compare  = std::less<_Key>, \fBtypename\fP _Alloc  = std::allocator<std::pair<const _Key, _Tp> >> \fBconst_iterator\fP \fBstd::multimap\fP< \fB_Key\fP, _Tp, _Compare, _Alloc >::begin () const\fC [inline]\fP, \fC [noexcept]\fP"
Returns a read-only (constant) iterator that points to the first pair in the multimap\&. Iteration is done in ascending order according to the keys\&. 
.SS "template<\fBtypename\fP \fB_Key\fP , \fBtypename\fP _Tp , \fBtypename\fP _Compare  = std::less<_Key>, \fBtypename\fP _Alloc  = std::allocator<std::pair<const _Key, _Tp> >> \fBiterator\fP \fBstd::multimap\fP< \fB_Key\fP, _Tp, _Compare, _Alloc >::begin ()\fC [inline]\fP, \fC [noexcept]\fP"
Returns a read/write iterator that points to the first pair in the multimap\&. Iteration is done in ascending order according to the keys\&. 
.SS "template<\fBtypename\fP \fB_Key\fP , \fBtypename\fP _Tp , \fBtypename\fP _Compare  = std::less<_Key>, \fBtypename\fP _Alloc  = std::allocator<std::pair<const _Key, _Tp> >> \fBconst_iterator\fP \fBstd::multimap\fP< \fB_Key\fP, _Tp, _Compare, _Alloc >::cbegin () const\fC [inline]\fP, \fC [noexcept]\fP"
Returns a read-only (constant) iterator that points to the first pair in the multimap\&. Iteration is done in ascending order according to the keys\&. 
.SS "template<\fBtypename\fP \fB_Key\fP , \fBtypename\fP _Tp , \fBtypename\fP _Compare  = std::less<_Key>, \fBtypename\fP _Alloc  = std::allocator<std::pair<const _Key, _Tp> >> \fBconst_iterator\fP \fBstd::multimap\fP< \fB_Key\fP, _Tp, _Compare, _Alloc >::cend () const\fC [inline]\fP, \fC [noexcept]\fP"
Returns a read-only (constant) iterator that points one past the last pair in the multimap\&. Iteration is done in ascending order according to the keys\&. 
.SS "template<\fBtypename\fP \fB_Key\fP , \fBtypename\fP _Tp , \fBtypename\fP _Compare  = std::less<_Key>, \fBtypename\fP _Alloc  = std::allocator<std::pair<const _Key, _Tp> >> \fBvoid\fP \fBstd::multimap\fP< \fB_Key\fP, _Tp, _Compare, _Alloc >::clear ()\fC [inline]\fP, \fC [noexcept]\fP"
Erases all elements in a multimap\&. Note that this function only erases the elements, and that if the elements themselves are pointers, the pointed-to memory is not touched in any way\&. Managing the pointer is the user's responsibility\&. 
.SS "template<\fBtypename\fP \fB_Key\fP , \fBtypename\fP _Tp , \fBtypename\fP _Compare  = std::less<_Key>, \fBtypename\fP _Alloc  = std::allocator<std::pair<const _Key, _Tp> >> template<\fBtypename\fP \fB_Kt\fP > \fBauto\fP \fBstd::multimap\fP< \fB_Key\fP, _Tp, _Compare, _Alloc >::count (\fBconst\fP \fB_Kt\fP & __x) const \-> \fBdecltype\fP(_M_t\&._M_count_tr(__x))
	\fC [inline]\fP"

.PP
Finds the number of elements with given key\&. 
.PP
\fBParameters\fP
.RS 4
\fI__x\fP Key of (key, value) pairs to be located\&. 
.RE
.PP
\fBReturns\fP
.RS 4
Number of elements with specified key\&. 
.RE
.PP

.SS "template<\fBtypename\fP \fB_Key\fP , \fBtypename\fP _Tp , \fBtypename\fP _Compare  = std::less<_Key>, \fBtypename\fP _Alloc  = std::allocator<std::pair<const _Key, _Tp> >> size_type \fBstd::multimap\fP< \fB_Key\fP, _Tp, _Compare, _Alloc >::count (\fBconst\fP \fBkey_type\fP & __x) const\fC [inline]\fP"

.PP
Finds the number of elements with given key\&. 
.PP
\fBParameters\fP
.RS 4
\fI__x\fP Key of (key, value) pairs to be located\&. 
.RE
.PP
\fBReturns\fP
.RS 4
Number of elements with specified key\&. 
.RE
.PP

.SS "template<\fBtypename\fP \fB_Key\fP , \fBtypename\fP _Tp , \fBtypename\fP _Compare  = std::less<_Key>, \fBtypename\fP _Alloc  = std::allocator<std::pair<const _Key, _Tp> >> \fBconst_reverse_iterator\fP \fBstd::multimap\fP< \fB_Key\fP, _Tp, _Compare, _Alloc >::crbegin () const\fC [inline]\fP, \fC [noexcept]\fP"
Returns a read-only (constant) reverse iterator that points to the last pair in the multimap\&. Iteration is done in descending order according to the keys\&. 
.SS "template<\fBtypename\fP \fB_Key\fP , \fBtypename\fP _Tp , \fBtypename\fP _Compare  = std::less<_Key>, \fBtypename\fP _Alloc  = std::allocator<std::pair<const _Key, _Tp> >> \fBconst_reverse_iterator\fP \fBstd::multimap\fP< \fB_Key\fP, _Tp, _Compare, _Alloc >::crend () const\fC [inline]\fP, \fC [noexcept]\fP"
Returns a read-only (constant) reverse iterator that points to one before the first pair in the multimap\&. Iteration is done in descending order according to the keys\&. 
.SS "template<\fBtypename\fP \fB_Key\fP , \fBtypename\fP _Tp , \fBtypename\fP _Compare  = std::less<_Key>, \fBtypename\fP _Alloc  = std::allocator<std::pair<const _Key, _Tp> >> template<typename\&.\&.\&. _Args> \fBiterator\fP \fBstd::multimap\fP< \fB_Key\fP, _Tp, _Compare, _Alloc >::emplace (\fB_Args\fP &&\&.\&.\&. __args)\fC [inline]\fP"

.PP
Build and insert a std::pair into the multimap\&. 
.PP
\fBParameters\fP
.RS 4
\fI__args\fP Arguments used to generate a new pair instance (see std::piecewise_contruct for passing arguments to each part of the pair constructor)\&.
.RE
.PP
\fBReturns\fP
.RS 4
An iterator that points to the inserted (key,value) pair\&.
.RE
.PP
This function builds and inserts a (key, value) pair into the multimap\&. Contrary to a std::map the multimap does not rely on unique keys and thus multiple pairs with the same key can be inserted\&.
.PP
Insertion requires logarithmic time\&. 
.SS "template<\fBtypename\fP \fB_Key\fP , \fBtypename\fP _Tp , \fBtypename\fP _Compare  = std::less<_Key>, \fBtypename\fP _Alloc  = std::allocator<std::pair<const _Key, _Tp> >> template<typename\&.\&.\&. _Args> \fBiterator\fP \fBstd::multimap\fP< \fB_Key\fP, _Tp, _Compare, _Alloc >::emplace_hint (\fBconst_iterator\fP __pos, \fB_Args\fP &&\&.\&.\&. __args)\fC [inline]\fP"

.PP
Builds and inserts a std::pair into the multimap\&. 
.PP
\fBParameters\fP
.RS 4
\fI__pos\fP An iterator that serves as a hint as to where the pair should be inserted\&. 
.br
\fI__args\fP Arguments used to generate a new pair instance (see std::piecewise_contruct for passing arguments to each part of the pair constructor)\&. 
.RE
.PP
\fBReturns\fP
.RS 4
An iterator that points to the inserted (key,value) pair\&.
.RE
.PP
This function inserts a (key, value) pair into the multimap\&. Contrary to a std::map the multimap does not rely on unique keys and thus multiple pairs with the same key can be inserted\&. Note that the first parameter is only a hint and can potentially improve the performance of the insertion process\&. A bad hint would cause no gains in efficiency\&.
.PP
For more on \fIhinting\fP, see: https://gcc.gnu.org/onlinedocs/libstdc++/manual/associative.html#containers.associative.insert_hints
.PP
Insertion requires logarithmic time (if the hint is not taken)\&. 
.SS "template<\fBtypename\fP \fB_Key\fP , \fBtypename\fP _Tp , \fBtypename\fP _Compare  = std::less<_Key>, \fBtypename\fP _Alloc  = std::allocator<std::pair<const _Key, _Tp> >> bool \fBstd::multimap\fP< \fB_Key\fP, _Tp, _Compare, _Alloc >::empty () const\fC [inline]\fP, \fC [noexcept]\fP"
Returns true if the multimap is empty\&. 
.br
 
.SS "template<\fBtypename\fP \fB_Key\fP , \fBtypename\fP _Tp , \fBtypename\fP _Compare  = std::less<_Key>, \fBtypename\fP _Alloc  = std::allocator<std::pair<const _Key, _Tp> >> \fBconst_iterator\fP \fBstd::multimap\fP< \fB_Key\fP, _Tp, _Compare, _Alloc >::end () const\fC [inline]\fP, \fC [noexcept]\fP"
Returns a read-only (constant) iterator that points one past the last pair in the multimap\&. Iteration is done in ascending order according to the keys\&. 
.SS "template<\fBtypename\fP \fB_Key\fP , \fBtypename\fP _Tp , \fBtypename\fP _Compare  = std::less<_Key>, \fBtypename\fP _Alloc  = std::allocator<std::pair<const _Key, _Tp> >> \fBiterator\fP \fBstd::multimap\fP< \fB_Key\fP, _Tp, _Compare, _Alloc >::end ()\fC [inline]\fP, \fC [noexcept]\fP"
Returns a read/write iterator that points one past the last pair in the multimap\&. Iteration is done in ascending order according to the keys\&. 
.PP
Referenced by \fBstd::multimap< _Key, _Tp, _Compare, _Alloc >::extract()\fP\&.
.SS "template<\fBtypename\fP \fB_Key\fP , \fBtypename\fP _Tp , \fBtypename\fP _Compare  = std::less<_Key>, \fBtypename\fP _Alloc  = std::allocator<std::pair<const _Key, _Tp> >> template<\fBtypename\fP \fB_Kt\fP > \fBauto\fP \fBstd::multimap\fP< \fB_Key\fP, _Tp, _Compare, _Alloc >::equal_range (\fBconst\fP \fB_Kt\fP & __x) \-> \fBdecltype\fP(\fBpair\fP<\fBiterator\fP, \fBiterator\fP>(_M_t\&._M_equal_range_tr(__x)))
	\fC [inline]\fP"

.PP
Finds a subsequence matching given key\&. 
.PP
\fBParameters\fP
.RS 4
\fI__x\fP Key of (key, value) pairs to be located\&. 
.RE
.PP
\fBReturns\fP
.RS 4
Pair of iterators that possibly points to the subsequence matching given key\&.
.RE
.PP
This function is equivalent to 
.PP
.nf
std::make_pair(c\&.lower_bound(val),
               c\&.upper_bound(val))

.fi
.PP
 (but is faster than making the calls separately)\&. 
.SS "template<\fBtypename\fP \fB_Key\fP , \fBtypename\fP _Tp , \fBtypename\fP _Compare  = std::less<_Key>, \fBtypename\fP _Alloc  = std::allocator<std::pair<const _Key, _Tp> >> template<\fBtypename\fP \fB_Kt\fP > \fBauto\fP \fBstd::multimap\fP< \fB_Key\fP, _Tp, _Compare, _Alloc >::equal_range (\fBconst\fP \fB_Kt\fP & __x) const \-> \fBdecltype\fP(\fBpair\fP<\fBconst_iterator\fP, \fBconst_iterator\fP>(
	      _M_t\&._M_equal_range_tr(__x)))
	\fC [inline]\fP"

.PP
Finds a subsequence matching given key\&. 
.PP
\fBParameters\fP
.RS 4
\fI__x\fP Key of (key, value) pairs to be located\&. 
.RE
.PP
\fBReturns\fP
.RS 4
Pair of read-only (constant) iterators that possibly points to the subsequence matching given key\&.
.RE
.PP
This function is equivalent to 
.PP
.nf
std::make_pair(c\&.lower_bound(val),
               c\&.upper_bound(val))

.fi
.PP
 (but is faster than making the calls separately)\&. 
.SS "template<\fBtypename\fP \fB_Key\fP , \fBtypename\fP _Tp , \fBtypename\fP _Compare  = std::less<_Key>, \fBtypename\fP _Alloc  = std::allocator<std::pair<const _Key, _Tp> >> \fBstd::pair\fP< \fBiterator\fP, \fBiterator\fP > \fBstd::multimap\fP< \fB_Key\fP, _Tp, _Compare, _Alloc >::equal_range (\fBconst\fP \fBkey_type\fP & __x)\fC [inline]\fP"

.PP
Finds a subsequence matching given key\&. 
.PP
\fBParameters\fP
.RS 4
\fI__x\fP Key of (key, value) pairs to be located\&. 
.RE
.PP
\fBReturns\fP
.RS 4
Pair of iterators that possibly points to the subsequence matching given key\&.
.RE
.PP
This function is equivalent to 
.PP
.nf
std::make_pair(c\&.lower_bound(val),
               c\&.upper_bound(val))

.fi
.PP
 (but is faster than making the calls separately)\&. 
.SS "template<\fBtypename\fP \fB_Key\fP , \fBtypename\fP _Tp , \fBtypename\fP _Compare  = std::less<_Key>, \fBtypename\fP _Alloc  = std::allocator<std::pair<const _Key, _Tp> >> \fBstd::pair\fP< \fBconst_iterator\fP, \fBconst_iterator\fP > \fBstd::multimap\fP< \fB_Key\fP, _Tp, _Compare, _Alloc >::equal_range (\fBconst\fP \fBkey_type\fP & __x) const\fC [inline]\fP"

.PP
Finds a subsequence matching given key\&. 
.PP
\fBParameters\fP
.RS 4
\fI__x\fP Key of (key, value) pairs to be located\&. 
.RE
.PP
\fBReturns\fP
.RS 4
Pair of read-only (constant) iterators that possibly points to the subsequence matching given key\&.
.RE
.PP
This function is equivalent to 
.PP
.nf
std::make_pair(c\&.lower_bound(val),
               c\&.upper_bound(val))

.fi
.PP
 (but is faster than making the calls separately)\&. 
.SS "template<\fBtypename\fP \fB_Key\fP , \fBtypename\fP _Tp , \fBtypename\fP _Compare  = std::less<_Key>, \fBtypename\fP _Alloc  = std::allocator<std::pair<const _Key, _Tp> >> size_type \fBstd::multimap\fP< \fB_Key\fP, _Tp, _Compare, _Alloc >::erase (\fBconst\fP \fBkey_type\fP & __x)\fC [inline]\fP"

.PP
Erases elements according to the provided key\&. 
.PP
\fBParameters\fP
.RS 4
\fI__x\fP Key of element to be erased\&. 
.RE
.PP
\fBReturns\fP
.RS 4
The number of elements erased\&.
.RE
.PP
This function erases all elements located by the given key from a multimap\&. Note that this function only erases the element, and that if the element is itself a pointer, the pointed-to memory is not touched in any way\&. Managing the pointer is the user's responsibility\&. 
.SS "template<\fBtypename\fP \fB_Key\fP , \fBtypename\fP _Tp , \fBtypename\fP _Compare  = std::less<_Key>, \fBtypename\fP _Alloc  = std::allocator<std::pair<const _Key, _Tp> >> \fBiterator\fP \fBstd::multimap\fP< \fB_Key\fP, _Tp, _Compare, _Alloc >::erase (\fBconst_iterator\fP __first, \fBconst_iterator\fP __last)\fC [inline]\fP"

.PP
Erases a [first,last) range of elements from a multimap\&. 
.PP
\fBParameters\fP
.RS 4
\fI__first\fP Iterator pointing to the start of the range to be erased\&. 
.br
\fI__last\fP Iterator pointing to the end of the range to be erased \&. 
.RE
.PP
\fBReturns\fP
.RS 4
The iterator \fI__last\fP\&.
.RE
.PP
This function erases a sequence of elements from a multimap\&. Note that this function only erases the elements, and that if the elements themselves are pointers, the pointed-to memory is not touched in any way\&. Managing the pointer is the user's responsibility\&. 
.SS "template<\fBtypename\fP \fB_Key\fP , \fBtypename\fP _Tp , \fBtypename\fP _Compare  = std::less<_Key>, \fBtypename\fP _Alloc  = std::allocator<std::pair<const _Key, _Tp> >> \fBiterator\fP \fBstd::multimap\fP< \fB_Key\fP, _Tp, _Compare, _Alloc >::erase (\fBconst_iterator\fP __position)\fC [inline]\fP"

.PP
Erases an element from a multimap\&. 
.PP
\fBParameters\fP
.RS 4
\fI__position\fP An iterator pointing to the element to be erased\&. 
.RE
.PP
\fBReturns\fP
.RS 4
An iterator pointing to the element immediately following \fIposition\fP prior to the element being erased\&. If no such element exists, end() is returned\&.
.RE
.PP
This function erases an element, pointed to by the given iterator, from a multimap\&. Note that this function only erases the element, and that if the element is itself a pointer, the pointed-to memory is not touched in any way\&. Managing the pointer is the user's responsibility\&. 
.SS "template<\fBtypename\fP \fB_Key\fP , \fBtypename\fP _Tp , \fBtypename\fP _Compare  = std::less<_Key>, \fBtypename\fP _Alloc  = std::allocator<std::pair<const _Key, _Tp> >> _GLIBCXX_ABI_TAG_CXX11 \fBiterator\fP \fBstd::multimap\fP< \fB_Key\fP, _Tp, _Compare, _Alloc >::erase (\fBiterator\fP __position)\fC [inline]\fP"

.PP
Erases an element from a multimap\&. 
.PP
\fBParameters\fP
.RS 4
\fI__position\fP An iterator pointing to the element to be erased\&. 
.RE
.PP
\fBReturns\fP
.RS 4
An iterator pointing to the element immediately following \fIposition\fP prior to the element being erased\&. If no such element exists, end() is returned\&.
.RE
.PP
This function erases an element, pointed to by the given iterator, from a multimap\&. Note that this function only erases the element, and that if the element is itself a pointer, the pointed-to memory is not touched in any way\&. Managing the pointer is the user's responsibility\&. 
.SS "template<\fBtypename\fP \fB_Key\fP , \fBtypename\fP _Tp , \fBtypename\fP _Compare  = std::less<_Key>, \fBtypename\fP _Alloc  = std::allocator<std::pair<const _Key, _Tp> >> node_type \fBstd::multimap\fP< \fB_Key\fP, _Tp, _Compare, _Alloc >::extract (\fBconst\fP \fBkey_type\fP & __x)\fC [inline]\fP"

.PP
Extract a node\&. 
.SS "template<\fBtypename\fP \fB_Key\fP , \fBtypename\fP _Tp , \fBtypename\fP _Compare  = std::less<_Key>, \fBtypename\fP _Alloc  = std::allocator<std::pair<const _Key, _Tp> >> node_type \fBstd::multimap\fP< \fB_Key\fP, _Tp, _Compare, _Alloc >::extract (\fBconst_iterator\fP __pos)\fC [inline]\fP"

.PP
Extract a node\&. 
.PP
References \fBstd::multimap< _Key, _Tp, _Compare, _Alloc >::end()\fP\&.
.SS "template<\fBtypename\fP \fB_Key\fP , \fBtypename\fP _Tp , \fBtypename\fP _Compare  = std::less<_Key>, \fBtypename\fP _Alloc  = std::allocator<std::pair<const _Key, _Tp> >> template<\fBtypename\fP \fB_Kt\fP > \fBauto\fP \fBstd::multimap\fP< \fB_Key\fP, _Tp, _Compare, _Alloc >::find (\fBconst\fP \fB_Kt\fP & __x) \-> \fBdecltype\fP(_M_t\&._M_find_tr(__x))
	\fC [inline]\fP"

.PP
Tries to locate an element in a multimap\&. 
.PP
\fBParameters\fP
.RS 4
\fI__x\fP Key of (key, value) pair to be located\&. 
.RE
.PP
\fBReturns\fP
.RS 4
Iterator pointing to sought-after element, or end() if not found\&.
.RE
.PP
This function takes a key and tries to locate the element with which the key matches\&. If successful the function returns an iterator pointing to the sought after pair\&. If unsuccessful it returns the past-the-end ( \fCend()\fP ) iterator\&. 
.SS "template<\fBtypename\fP \fB_Key\fP , \fBtypename\fP _Tp , \fBtypename\fP _Compare  = std::less<_Key>, \fBtypename\fP _Alloc  = std::allocator<std::pair<const _Key, _Tp> >> template<\fBtypename\fP \fB_Kt\fP > \fBauto\fP \fBstd::multimap\fP< \fB_Key\fP, _Tp, _Compare, _Alloc >::find (\fBconst\fP \fB_Kt\fP & __x) const \-> \fBdecltype\fP(_M_t\&._M_find_tr(__x))
	\fC [inline]\fP"

.PP
Tries to locate an element in a multimap\&. 
.PP
\fBParameters\fP
.RS 4
\fI__x\fP Key of (key, value) pair to be located\&. 
.RE
.PP
\fBReturns\fP
.RS 4
Read-only (constant) iterator pointing to sought-after element, or end() if not found\&.
.RE
.PP
This function takes a key and tries to locate the element with which the key matches\&. If successful the function returns a constant iterator pointing to the sought after pair\&. If unsuccessful it returns the past-the-end ( \fCend()\fP ) iterator\&. 
.SS "template<\fBtypename\fP \fB_Key\fP , \fBtypename\fP _Tp , \fBtypename\fP _Compare  = std::less<_Key>, \fBtypename\fP _Alloc  = std::allocator<std::pair<const _Key, _Tp> >> \fBiterator\fP \fBstd::multimap\fP< \fB_Key\fP, _Tp, _Compare, _Alloc >::find (\fBconst\fP \fBkey_type\fP & __x)\fC [inline]\fP"

.PP
Tries to locate an element in a multimap\&. 
.PP
\fBParameters\fP
.RS 4
\fI__x\fP Key of (key, value) pair to be located\&. 
.RE
.PP
\fBReturns\fP
.RS 4
Iterator pointing to sought-after element, or end() if not found\&.
.RE
.PP
This function takes a key and tries to locate the element with which the key matches\&. If successful the function returns an iterator pointing to the sought after pair\&. If unsuccessful it returns the past-the-end ( \fCend()\fP ) iterator\&. 
.SS "template<\fBtypename\fP \fB_Key\fP , \fBtypename\fP _Tp , \fBtypename\fP _Compare  = std::less<_Key>, \fBtypename\fP _Alloc  = std::allocator<std::pair<const _Key, _Tp> >> \fBconst_iterator\fP \fBstd::multimap\fP< \fB_Key\fP, _Tp, _Compare, _Alloc >::find (\fBconst\fP \fBkey_type\fP & __x) const\fC [inline]\fP"

.PP
Tries to locate an element in a multimap\&. 
.PP
\fBParameters\fP
.RS 4
\fI__x\fP Key of (key, value) pair to be located\&. 
.RE
.PP
\fBReturns\fP
.RS 4
Read-only (constant) iterator pointing to sought-after element, or end() if not found\&.
.RE
.PP
This function takes a key and tries to locate the element with which the key matches\&. If successful the function returns a constant iterator pointing to the sought after pair\&. If unsuccessful it returns the past-the-end ( \fCend()\fP ) iterator\&. 
.SS "template<\fBtypename\fP \fB_Key\fP , \fBtypename\fP _Tp , \fBtypename\fP _Compare  = std::less<_Key>, \fBtypename\fP _Alloc  = std::allocator<std::pair<const _Key, _Tp> >> allocator_type \fBstd::multimap\fP< \fB_Key\fP, _Tp, _Compare, _Alloc >::get_allocator () const\fC [inline]\fP, \fC [noexcept]\fP"

.PP
Get a copy of the memory allocation object\&. 
.SS "template<\fBtypename\fP \fB_Key\fP , \fBtypename\fP _Tp , \fBtypename\fP _Compare  = std::less<_Key>, \fBtypename\fP _Alloc  = std::allocator<std::pair<const _Key, _Tp> >> template<\fBtypename\fP \fB_InputIterator\fP > \fBvoid\fP \fBstd::multimap\fP< \fB_Key\fP, _Tp, _Compare, _Alloc >::insert (\fB_InputIterator\fP __first, \fB_InputIterator\fP __last)\fC [inline]\fP"

.PP
A template function that attempts to insert a range of elements\&. 
.PP
\fBParameters\fP
.RS 4
\fI__first\fP Iterator pointing to the start of the range to be inserted\&. 
.br
\fI__last\fP Iterator pointing to the end of the range\&.
.RE
.PP
Complexity similar to that of the range constructor\&. 
.SS "template<\fBtypename\fP \fB_Key\fP , \fBtypename\fP _Tp , \fBtypename\fP _Compare  = std::less<_Key>, \fBtypename\fP _Alloc  = std::allocator<std::pair<const _Key, _Tp> >> template<\fBtypename\fP \fB_Pair\fP > \fB__enable_if_t\fP< \fBis_constructible\fP< \fBvalue_type\fP, \fB_Pair\fP >::value, \fBiterator\fP > \fBstd::multimap\fP< \fB_Key\fP, _Tp, _Compare, _Alloc >::insert (\fB_Pair\fP && __x)\fC [inline]\fP"

.PP
Inserts a std::pair into the multimap\&. 
.PP
\fBParameters\fP
.RS 4
\fI__x\fP Pair to be inserted (see std::make_pair for easy creation of pairs)\&. 
.RE
.PP
\fBReturns\fP
.RS 4
An iterator that points to the inserted (key,value) pair\&.
.RE
.PP
This function inserts a (key, value) pair into the multimap\&. Contrary to a std::map the multimap does not rely on unique keys and thus multiple pairs with the same key can be inserted\&.
.PP
Insertion requires logarithmic time\&. 
.SS "template<\fBtypename\fP \fB_Key\fP , \fBtypename\fP _Tp , \fBtypename\fP _Compare  = std::less<_Key>, \fBtypename\fP _Alloc  = std::allocator<std::pair<const _Key, _Tp> >> \fBiterator\fP \fBstd::multimap\fP< \fB_Key\fP, _Tp, _Compare, _Alloc >::insert (\fBconst\fP \fBvalue_type\fP & __x)\fC [inline]\fP"

.PP
Inserts a std::pair into the multimap\&. 
.PP
\fBParameters\fP
.RS 4
\fI__x\fP Pair to be inserted (see std::make_pair for easy creation of pairs)\&. 
.RE
.PP
\fBReturns\fP
.RS 4
An iterator that points to the inserted (key,value) pair\&.
.RE
.PP
This function inserts a (key, value) pair into the multimap\&. Contrary to a std::map the multimap does not rely on unique keys and thus multiple pairs with the same key can be inserted\&.
.PP
Insertion requires logarithmic time\&. 
.PP
Referenced by \fBstd::multimap< _Key, _Tp, _Compare, _Alloc >::insert()\fP\&.
.SS "template<\fBtypename\fP \fB_Key\fP , \fBtypename\fP _Tp , \fBtypename\fP _Compare  = std::less<_Key>, \fBtypename\fP _Alloc  = std::allocator<std::pair<const _Key, _Tp> >> \fBiterator\fP \fBstd::multimap\fP< \fB_Key\fP, _Tp, _Compare, _Alloc >::insert (\fBconst_iterator\fP __hint, node_type && __nh)\fC [inline]\fP"

.PP
Re-insert an extracted node\&. 
.PP
References \fBstd::move()\fP\&.
.SS "template<\fBtypename\fP \fB_Key\fP , \fBtypename\fP _Tp , \fBtypename\fP _Compare  = std::less<_Key>, \fBtypename\fP _Alloc  = std::allocator<std::pair<const _Key, _Tp> >> template<\fBtypename\fP \fB_Pair\fP > \fB__enable_if_t\fP< \fBis_constructible\fP< \fBvalue_type\fP, \fB_Pair\fP && >::value, \fBiterator\fP > \fBstd::multimap\fP< \fB_Key\fP, _Tp, _Compare, _Alloc >::insert (\fBconst_iterator\fP __position, \fB_Pair\fP && __x)\fC [inline]\fP"

.PP
Inserts a std::pair into the multimap\&. 
.PP
\fBParameters\fP
.RS 4
\fI__position\fP An iterator that serves as a hint as to where the pair should be inserted\&. 
.br
\fI__x\fP Pair to be inserted (see std::make_pair for easy creation of pairs)\&. 
.RE
.PP
\fBReturns\fP
.RS 4
An iterator that points to the inserted (key,value) pair\&.
.RE
.PP
This function inserts a (key, value) pair into the multimap\&. Contrary to a std::map the multimap does not rely on unique keys and thus multiple pairs with the same key can be inserted\&. Note that the first parameter is only a hint and can potentially improve the performance of the insertion process\&. A bad hint would cause no gains in efficiency\&.
.PP
For more on \fIhinting\fP, see: https://gcc.gnu.org/onlinedocs/libstdc++/manual/associative.html#containers.associative.insert_hints
.PP
Insertion requires logarithmic time (if the hint is not taken)\&. 
.SS "template<\fBtypename\fP \fB_Key\fP , \fBtypename\fP _Tp , \fBtypename\fP _Compare  = std::less<_Key>, \fBtypename\fP _Alloc  = std::allocator<std::pair<const _Key, _Tp> >> \fBiterator\fP \fBstd::multimap\fP< \fB_Key\fP, _Tp, _Compare, _Alloc >::insert (\fBconst_iterator\fP __position, \fBconst\fP \fBvalue_type\fP & __x)\fC [inline]\fP"

.PP
Inserts a std::pair into the multimap\&. 
.PP
\fBParameters\fP
.RS 4
\fI__position\fP An iterator that serves as a hint as to where the pair should be inserted\&. 
.br
\fI__x\fP Pair to be inserted (see std::make_pair for easy creation of pairs)\&. 
.RE
.PP
\fBReturns\fP
.RS 4
An iterator that points to the inserted (key,value) pair\&.
.RE
.PP
This function inserts a (key, value) pair into the multimap\&. Contrary to a std::map the multimap does not rely on unique keys and thus multiple pairs with the same key can be inserted\&. Note that the first parameter is only a hint and can potentially improve the performance of the insertion process\&. A bad hint would cause no gains in efficiency\&.
.PP
For more on \fIhinting\fP, see: https://gcc.gnu.org/onlinedocs/libstdc++/manual/associative.html#containers.associative.insert_hints
.PP
Insertion requires logarithmic time (if the hint is not taken)\&. 
.SS "template<\fBtypename\fP \fB_Key\fP , \fBtypename\fP _Tp , \fBtypename\fP _Compare  = std::less<_Key>, \fBtypename\fP _Alloc  = std::allocator<std::pair<const _Key, _Tp> >> \fBiterator\fP \fBstd::multimap\fP< \fB_Key\fP, _Tp, _Compare, _Alloc >::insert (\fBconst_iterator\fP __position, \fBvalue_type\fP && __x)\fC [inline]\fP"

.PP
Inserts a std::pair into the multimap\&. 
.PP
\fBParameters\fP
.RS 4
\fI__position\fP An iterator that serves as a hint as to where the pair should be inserted\&. 
.br
\fI__x\fP Pair to be inserted (see std::make_pair for easy creation of pairs)\&. 
.RE
.PP
\fBReturns\fP
.RS 4
An iterator that points to the inserted (key,value) pair\&.
.RE
.PP
This function inserts a (key, value) pair into the multimap\&. Contrary to a std::map the multimap does not rely on unique keys and thus multiple pairs with the same key can be inserted\&. Note that the first parameter is only a hint and can potentially improve the performance of the insertion process\&. A bad hint would cause no gains in efficiency\&.
.PP
For more on \fIhinting\fP, see: https://gcc.gnu.org/onlinedocs/libstdc++/manual/associative.html#containers.associative.insert_hints
.PP
Insertion requires logarithmic time (if the hint is not taken)\&. 
.PP
References \fBstd::move()\fP\&.
.SS "template<\fBtypename\fP \fB_Key\fP , \fBtypename\fP _Tp , \fBtypename\fP _Compare  = std::less<_Key>, \fBtypename\fP _Alloc  = std::allocator<std::pair<const _Key, _Tp> >> \fBvoid\fP \fBstd::multimap\fP< \fB_Key\fP, _Tp, _Compare, _Alloc >::insert (\fBinitializer_list\fP< \fBvalue_type\fP > __l)\fC [inline]\fP"

.PP
Attempts to insert a list of std::pairs into the multimap\&. 
.PP
\fBParameters\fP
.RS 4
\fI__l\fP A std::initializer_list<value_type> of pairs to be inserted\&.
.RE
.PP
Complexity similar to that of the range constructor\&. 
.PP
References \fBstd::multimap< _Key, _Tp, _Compare, _Alloc >::insert()\fP\&.
.SS "template<\fBtypename\fP \fB_Key\fP , \fBtypename\fP _Tp , \fBtypename\fP _Compare  = std::less<_Key>, \fBtypename\fP _Alloc  = std::allocator<std::pair<const _Key, _Tp> >> \fBiterator\fP \fBstd::multimap\fP< \fB_Key\fP, _Tp, _Compare, _Alloc >::insert (node_type && __nh)\fC [inline]\fP"

.PP
Re-insert an extracted node\&. 
.PP
References \fBstd::move()\fP\&.
.SS "template<\fBtypename\fP \fB_Key\fP , \fBtypename\fP _Tp , \fBtypename\fP _Compare  = std::less<_Key>, \fBtypename\fP _Alloc  = std::allocator<std::pair<const _Key, _Tp> >> \fBiterator\fP \fBstd::multimap\fP< \fB_Key\fP, _Tp, _Compare, _Alloc >::insert (\fBvalue_type\fP && __x)\fC [inline]\fP"

.PP
Inserts a std::pair into the multimap\&. 
.PP
\fBParameters\fP
.RS 4
\fI__x\fP Pair to be inserted (see std::make_pair for easy creation of pairs)\&. 
.RE
.PP
\fBReturns\fP
.RS 4
An iterator that points to the inserted (key,value) pair\&.
.RE
.PP
This function inserts a (key, value) pair into the multimap\&. Contrary to a std::map the multimap does not rely on unique keys and thus multiple pairs with the same key can be inserted\&.
.PP
Insertion requires logarithmic time\&. 
.PP
References \fBstd::move()\fP\&.
.SS "template<\fBtypename\fP \fB_Key\fP , \fBtypename\fP _Tp , \fBtypename\fP _Compare  = std::less<_Key>, \fBtypename\fP _Alloc  = std::allocator<std::pair<const _Key, _Tp> >> key_compare \fBstd::multimap\fP< \fB_Key\fP, _Tp, _Compare, _Alloc >::key_comp () const\fC [inline]\fP"
Returns the key comparison object out of which the multimap was constructed\&. 
.SS "template<\fBtypename\fP \fB_Key\fP , \fBtypename\fP _Tp , \fBtypename\fP _Compare  = std::less<_Key>, \fBtypename\fP _Alloc  = std::allocator<std::pair<const _Key, _Tp> >> template<\fBtypename\fP \fB_Kt\fP > \fBauto\fP \fBstd::multimap\fP< \fB_Key\fP, _Tp, _Compare, _Alloc >::lower_bound (\fBconst\fP \fB_Kt\fP & __x) \-> \fBdecltype\fP(\fBiterator\fP(_M_t\&._M_lower_bound_tr(__x)))
	\fC [inline]\fP"

.PP
Finds the beginning of a subsequence matching given key\&. 
.PP
\fBParameters\fP
.RS 4
\fI__x\fP Key of (key, value) pair to be located\&. 
.RE
.PP
\fBReturns\fP
.RS 4
Iterator pointing to first element equal to or greater than key, or end()\&.
.RE
.PP
This function returns the first element of a subsequence of elements that matches the given key\&. If unsuccessful it returns an iterator pointing to the first element that has a greater value than given key or end() if no such element exists\&. 
.SS "template<\fBtypename\fP \fB_Key\fP , \fBtypename\fP _Tp , \fBtypename\fP _Compare  = std::less<_Key>, \fBtypename\fP _Alloc  = std::allocator<std::pair<const _Key, _Tp> >> template<\fBtypename\fP \fB_Kt\fP > \fBauto\fP \fBstd::multimap\fP< \fB_Key\fP, _Tp, _Compare, _Alloc >::lower_bound (\fBconst\fP \fB_Kt\fP & __x) const \-> \fBdecltype\fP(\fBconst_iterator\fP(_M_t\&._M_lower_bound_tr(__x)))
	\fC [inline]\fP"

.PP
Finds the beginning of a subsequence matching given key\&. 
.PP
\fBParameters\fP
.RS 4
\fI__x\fP Key of (key, value) pair to be located\&. 
.RE
.PP
\fBReturns\fP
.RS 4
Read-only (constant) iterator pointing to first element equal to or greater than key, or end()\&.
.RE
.PP
This function returns the first element of a subsequence of elements that matches the given key\&. If unsuccessful the iterator will point to the next greatest element or, if no such greater element exists, to end()\&. 
.SS "template<\fBtypename\fP \fB_Key\fP , \fBtypename\fP _Tp , \fBtypename\fP _Compare  = std::less<_Key>, \fBtypename\fP _Alloc  = std::allocator<std::pair<const _Key, _Tp> >> \fBiterator\fP \fBstd::multimap\fP< \fB_Key\fP, _Tp, _Compare, _Alloc >::lower_bound (\fBconst\fP \fBkey_type\fP & __x)\fC [inline]\fP"

.PP
Finds the beginning of a subsequence matching given key\&. 
.PP
\fBParameters\fP
.RS 4
\fI__x\fP Key of (key, value) pair to be located\&. 
.RE
.PP
\fBReturns\fP
.RS 4
Iterator pointing to first element equal to or greater than key, or end()\&.
.RE
.PP
This function returns the first element of a subsequence of elements that matches the given key\&. If unsuccessful it returns an iterator pointing to the first element that has a greater value than given key or end() if no such element exists\&. 
.SS "template<\fBtypename\fP \fB_Key\fP , \fBtypename\fP _Tp , \fBtypename\fP _Compare  = std::less<_Key>, \fBtypename\fP _Alloc  = std::allocator<std::pair<const _Key, _Tp> >> \fBconst_iterator\fP \fBstd::multimap\fP< \fB_Key\fP, _Tp, _Compare, _Alloc >::lower_bound (\fBconst\fP \fBkey_type\fP & __x) const\fC [inline]\fP"

.PP
Finds the beginning of a subsequence matching given key\&. 
.PP
\fBParameters\fP
.RS 4
\fI__x\fP Key of (key, value) pair to be located\&. 
.RE
.PP
\fBReturns\fP
.RS 4
Read-only (constant) iterator pointing to first element equal to or greater than key, or end()\&.
.RE
.PP
This function returns the first element of a subsequence of elements that matches the given key\&. If unsuccessful the iterator will point to the next greatest element or, if no such greater element exists, to end()\&. 
.SS "template<\fBtypename\fP \fB_Key\fP , \fBtypename\fP _Tp , \fBtypename\fP _Compare  = std::less<_Key>, \fBtypename\fP _Alloc  = std::allocator<std::pair<const _Key, _Tp> >> size_type \fBstd::multimap\fP< \fB_Key\fP, _Tp, _Compare, _Alloc >::max_size () const\fC [inline]\fP, \fC [noexcept]\fP"
Returns the maximum size of the multimap\&. 
.br
 
.SS "template<\fBtypename\fP \fB_Key\fP , \fBtypename\fP _Tp , \fBtypename\fP _Compare  = std::less<_Key>, \fBtypename\fP _Alloc  = std::allocator<std::pair<const _Key, _Tp> >> \fBmultimap\fP & \fBstd::multimap\fP< \fB_Key\fP, _Tp, _Compare, _Alloc >::operator= (\fBconst\fP \fBmultimap\fP< \fB_Key\fP, _Tp, _Compare, _Alloc > &)\fC [default]\fP"

.PP
Multimap assignment operator\&. Whether the allocator is copied depends on the allocator traits\&. 
.SS "template<\fBtypename\fP \fB_Key\fP , \fBtypename\fP _Tp , \fBtypename\fP _Compare  = std::less<_Key>, \fBtypename\fP _Alloc  = std::allocator<std::pair<const _Key, _Tp> >> \fBmultimap\fP & \fBstd::multimap\fP< \fB_Key\fP, _Tp, _Compare, _Alloc >::operator= (\fBinitializer_list\fP< \fBvalue_type\fP > __l)\fC [inline]\fP"

.PP
Multimap list assignment operator\&. 
.PP
\fBParameters\fP
.RS 4
\fI__l\fP An initializer_list\&.
.RE
.PP
This function fills a multimap with copies of the elements in the initializer list \fI__l\fP\&.
.PP
Note that the assignment completely changes the multimap and that the resulting multimap's size is the same as the number of elements assigned\&. 
.SS "template<\fBtypename\fP \fB_Key\fP , \fBtypename\fP _Tp , \fBtypename\fP _Compare  = std::less<_Key>, \fBtypename\fP _Alloc  = std::allocator<std::pair<const _Key, _Tp> >> \fBmultimap\fP & \fBstd::multimap\fP< \fB_Key\fP, _Tp, _Compare, _Alloc >::operator= (\fBmultimap\fP< \fB_Key\fP, _Tp, _Compare, _Alloc > &&)\fC [default]\fP"

.PP
Move assignment operator\&. 
.SS "template<\fBtypename\fP \fB_Key\fP , \fBtypename\fP _Tp , \fBtypename\fP _Compare  = std::less<_Key>, \fBtypename\fP _Alloc  = std::allocator<std::pair<const _Key, _Tp> >> \fBconst_reverse_iterator\fP \fBstd::multimap\fP< \fB_Key\fP, _Tp, _Compare, _Alloc >::rbegin () const\fC [inline]\fP, \fC [noexcept]\fP"
Returns a read-only (constant) reverse iterator that points to the last pair in the multimap\&. Iteration is done in descending order according to the keys\&. 
.SS "template<\fBtypename\fP \fB_Key\fP , \fBtypename\fP _Tp , \fBtypename\fP _Compare  = std::less<_Key>, \fBtypename\fP _Alloc  = std::allocator<std::pair<const _Key, _Tp> >> \fBreverse_iterator\fP \fBstd::multimap\fP< \fB_Key\fP, _Tp, _Compare, _Alloc >::rbegin ()\fC [inline]\fP, \fC [noexcept]\fP"
Returns a read/write reverse iterator that points to the last pair in the multimap\&. Iteration is done in descending order according to the keys\&. 
.SS "template<\fBtypename\fP \fB_Key\fP , \fBtypename\fP _Tp , \fBtypename\fP _Compare  = std::less<_Key>, \fBtypename\fP _Alloc  = std::allocator<std::pair<const _Key, _Tp> >> \fBconst_reverse_iterator\fP \fBstd::multimap\fP< \fB_Key\fP, _Tp, _Compare, _Alloc >::rend () const\fC [inline]\fP, \fC [noexcept]\fP"
Returns a read-only (constant) reverse iterator that points to one before the first pair in the multimap\&. Iteration is done in descending order according to the keys\&. 
.SS "template<\fBtypename\fP \fB_Key\fP , \fBtypename\fP _Tp , \fBtypename\fP _Compare  = std::less<_Key>, \fBtypename\fP _Alloc  = std::allocator<std::pair<const _Key, _Tp> >> \fBreverse_iterator\fP \fBstd::multimap\fP< \fB_Key\fP, _Tp, _Compare, _Alloc >::rend ()\fC [inline]\fP, \fC [noexcept]\fP"
Returns a read/write reverse iterator that points to one before the first pair in the multimap\&. Iteration is done in descending order according to the keys\&. 
.SS "template<\fBtypename\fP \fB_Key\fP , \fBtypename\fP _Tp , \fBtypename\fP _Compare  = std::less<_Key>, \fBtypename\fP _Alloc  = std::allocator<std::pair<const _Key, _Tp> >> size_type \fBstd::multimap\fP< \fB_Key\fP, _Tp, _Compare, _Alloc >::size () const\fC [inline]\fP, \fC [noexcept]\fP"
Returns the size of the multimap\&. 
.br
 
.SS "template<\fBtypename\fP \fB_Key\fP , \fBtypename\fP _Tp , \fBtypename\fP _Compare  = std::less<_Key>, \fBtypename\fP _Alloc  = std::allocator<std::pair<const _Key, _Tp> >> \fBvoid\fP \fBstd::multimap\fP< \fB_Key\fP, _Tp, _Compare, _Alloc >::swap (\fBmultimap\fP< \fB_Key\fP, _Tp, _Compare, _Alloc > & __x)\fC [inline]\fP, \fC [noexcept]\fP"

.PP
Swaps data with another multimap\&. 
.PP
\fBParameters\fP
.RS 4
\fI__x\fP A multimap of the same element and allocator types\&.
.RE
.PP
This exchanges the elements between two multimaps in constant time\&. (It is only swapping a pointer, an integer, and an instance of the \fCCompare\fP type (which itself is often stateless and empty), so it should be quite fast\&.) Note that the global std::swap() function is specialized such that std::swap(m1,m2) will feed to this function\&.
.PP
Whether the allocators are swapped depends on the allocator traits\&. 
.SS "template<\fBtypename\fP \fB_Key\fP , \fBtypename\fP _Tp , \fBtypename\fP _Compare  = std::less<_Key>, \fBtypename\fP _Alloc  = std::allocator<std::pair<const _Key, _Tp> >> template<\fBtypename\fP \fB_Kt\fP > \fBauto\fP \fBstd::multimap\fP< \fB_Key\fP, _Tp, _Compare, _Alloc >::upper_bound (\fBconst\fP \fB_Kt\fP & __x) \-> \fBdecltype\fP(\fBiterator\fP(_M_t\&._M_upper_bound_tr(__x)))
	\fC [inline]\fP"

.PP
Finds the end of a subsequence matching given key\&. 
.PP
\fBParameters\fP
.RS 4
\fI__x\fP Key of (key, value) pair to be located\&. 
.RE
.PP
\fBReturns\fP
.RS 4
Iterator pointing to the first element greater than key, or end()\&. 
.RE
.PP

.SS "template<\fBtypename\fP \fB_Key\fP , \fBtypename\fP _Tp , \fBtypename\fP _Compare  = std::less<_Key>, \fBtypename\fP _Alloc  = std::allocator<std::pair<const _Key, _Tp> >> template<\fBtypename\fP \fB_Kt\fP > \fBauto\fP \fBstd::multimap\fP< \fB_Key\fP, _Tp, _Compare, _Alloc >::upper_bound (\fBconst\fP \fB_Kt\fP & __x) const \-> \fBdecltype\fP(\fBconst_iterator\fP(_M_t\&._M_upper_bound_tr(__x)))
	\fC [inline]\fP"

.PP
Finds the end of a subsequence matching given key\&. 
.PP
\fBParameters\fP
.RS 4
\fI__x\fP Key of (key, value) pair to be located\&. 
.RE
.PP
\fBReturns\fP
.RS 4
Read-only (constant) iterator pointing to first iterator greater than key, or end()\&. 
.RE
.PP

.SS "template<\fBtypename\fP \fB_Key\fP , \fBtypename\fP _Tp , \fBtypename\fP _Compare  = std::less<_Key>, \fBtypename\fP _Alloc  = std::allocator<std::pair<const _Key, _Tp> >> \fBiterator\fP \fBstd::multimap\fP< \fB_Key\fP, _Tp, _Compare, _Alloc >::upper_bound (\fBconst\fP \fBkey_type\fP & __x)\fC [inline]\fP"

.PP
Finds the end of a subsequence matching given key\&. 
.PP
\fBParameters\fP
.RS 4
\fI__x\fP Key of (key, value) pair to be located\&. 
.RE
.PP
\fBReturns\fP
.RS 4
Iterator pointing to the first element greater than key, or end()\&. 
.RE
.PP

.SS "template<\fBtypename\fP \fB_Key\fP , \fBtypename\fP _Tp , \fBtypename\fP _Compare  = std::less<_Key>, \fBtypename\fP _Alloc  = std::allocator<std::pair<const _Key, _Tp> >> \fBconst_iterator\fP \fBstd::multimap\fP< \fB_Key\fP, _Tp, _Compare, _Alloc >::upper_bound (\fBconst\fP \fBkey_type\fP & __x) const\fC [inline]\fP"

.PP
Finds the end of a subsequence matching given key\&. 
.PP
\fBParameters\fP
.RS 4
\fI__x\fP Key of (key, value) pair to be located\&. 
.RE
.PP
\fBReturns\fP
.RS 4
Read-only (constant) iterator pointing to first iterator greater than key, or end()\&. 
.RE
.PP

.SS "template<\fBtypename\fP \fB_Key\fP , \fBtypename\fP _Tp , \fBtypename\fP _Compare  = std::less<_Key>, \fBtypename\fP _Alloc  = std::allocator<std::pair<const _Key, _Tp> >> value_compare \fBstd::multimap\fP< \fB_Key\fP, _Tp, _Compare, _Alloc >::value_comp () const\fC [inline]\fP"
Returns a value comparison object, built from the key comparison object out of which the multimap was constructed\&. 

.SH "Author"
.PP 
Generated automatically by Doxygen for libstdc++ from the source code\&.