• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
2<html>
3<head>
4<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
5<title>Class template multimap</title>
6<link rel="stylesheet" href="../../../../doc/src/boostbook.css" type="text/css">
7<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
8<link rel="home" href="../../index.html" title="The Boost C++ Libraries BoostBook Documentation Subset">
9<link rel="up" href="../../boost_container_header_reference.html#header.boost.container.map_hpp" title="Header &lt;boost/container/map.hpp&gt;">
10<link rel="prev" href="map.html" title="Class template map">
11<link rel="next" href="pmr/map_of.html" title="Struct template map_of">
12</head>
13<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
14<table cellpadding="2" width="100%"><tr>
15<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../boost.png"></td>
16<td align="center"><a href="../../../../index.html">Home</a></td>
17<td align="center"><a href="../../../../libs/libraries.htm">Libraries</a></td>
18<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
19<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
20<td align="center"><a href="../../../../more/index.htm">More</a></td>
21</tr></table>
22<hr>
23<div class="spirit-nav">
24<a accesskey="p" href="map.html"><img src="../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../../boost_container_header_reference.html#header.boost.container.map_hpp"><img src="../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="pmr/map_of.html"><img src="../../../../doc/src/images/next.png" alt="Next"></a>
25</div>
26<div class="refentry">
27<a name="boost.container.multimap"></a><div class="titlepage"></div>
28<div class="refnamediv">
29<h2><span class="refentrytitle">Class template multimap</span></h2>
30<p>boost::container::multimap</p>
31</div>
32<h2 xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" class="refsynopsisdiv-title">Synopsis</h2>
33<div xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" class="refsynopsisdiv"><pre class="synopsis"><span class="comment">// In header: &lt;<a class="link" href="../../boost_container_header_reference.html#header.boost.container.map_hpp" title="Header &lt;boost/container/map.hpp&gt;">boost/container/map.hpp</a>&gt;
34
35</span><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> Key<span class="special">,</span> <span class="keyword">typename</span> T<span class="special">,</span> <span class="keyword">typename</span> Compare <span class="special">=</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">less</span><span class="special">&lt;</span><span class="identifier">Key</span><span class="special">&gt;</span><span class="special">,</span>
36         <span class="keyword">typename</span> Allocator <span class="special">=</span> <a class="link" href="new_allocator.html" title="Class template new_allocator">new_allocator</a><span class="special">&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span> <span class="keyword">const</span> <span class="identifier">Key</span><span class="special">,</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="special">&gt;</span><span class="special">,</span>
37         <span class="keyword">typename</span> Options <span class="special">=</span> <span class="identifier">tree_assoc_defaults</span><span class="special">&gt;</span>
38<span class="keyword">class</span> <a class="link" href="multimap.html" title="Class template multimap">multimap</a> <span class="special">{</span>
39<span class="keyword">public</span><span class="special">:</span>
40  <span class="comment">// types</span>
41  <span class="keyword">typedef</span> <span class="identifier">Key</span>                                                                   <a name="boost.container.multimap.key_type"></a><span class="identifier">key_type</span><span class="special">;</span>
42  <span class="keyword">typedef</span> <span class="identifier">T</span>                                                                     <a name="boost.container.multimap.mapped_type"></a><span class="identifier">mapped_type</span><span class="special">;</span>
43  <span class="keyword">typedef</span> <span class="identifier">base_t</span><span class="special">::</span><span class="identifier">allocator_type</span>                                                <a name="boost.container.multimap.allocator_type"></a><span class="identifier">allocator_type</span><span class="special">;</span>
44  <span class="keyword">typedef</span> <span class="special">::</span><a class="link" href="allocator_traits.html" title="Struct template allocator_traits">boost::container::allocator_traits</a><span class="special">&lt;</span> <span class="identifier">allocator_type</span> <span class="special">&gt;</span>                <a name="boost.container.multimap.allocator_traits_type"></a><span class="identifier">allocator_traits_type</span><span class="special">;</span>
45  <span class="keyword">typedef</span> <a class="link" href="allocator_traits.html" title="Struct template allocator_traits">boost::container::allocator_traits</a><span class="special">&lt;</span> <span class="identifier">allocator_type</span> <span class="special">&gt;</span><span class="special">::</span><span class="identifier">value_type</span>      <a name="boost.container.multimap.value_type"></a><span class="identifier">value_type</span><span class="special">;</span>
46  <span class="keyword">typedef</span> <a class="link" href="allocator_traits.html" title="Struct template allocator_traits">boost::container::allocator_traits</a><span class="special">&lt;</span> <span class="identifier">allocator_type</span> <span class="special">&gt;</span><span class="special">::</span><span class="identifier">pointer</span>         <a name="boost.container.multimap.pointer"></a><span class="identifier">pointer</span><span class="special">;</span>
47  <span class="keyword">typedef</span> <a class="link" href="allocator_traits.html" title="Struct template allocator_traits">boost::container::allocator_traits</a><span class="special">&lt;</span> <span class="identifier">allocator_type</span> <span class="special">&gt;</span><span class="special">::</span><span class="identifier">const_pointer</span>   <a name="boost.container.multimap.const_pointer"></a><span class="identifier">const_pointer</span><span class="special">;</span>
48  <span class="keyword">typedef</span> <a class="link" href="allocator_traits.html" title="Struct template allocator_traits">boost::container::allocator_traits</a><span class="special">&lt;</span> <span class="identifier">allocator_type</span> <span class="special">&gt;</span><span class="special">::</span><span class="identifier">reference</span>       <a name="boost.container.multimap.reference"></a><span class="identifier">reference</span><span class="special">;</span>
49  <span class="keyword">typedef</span> <a class="link" href="allocator_traits.html" title="Struct template allocator_traits">boost::container::allocator_traits</a><span class="special">&lt;</span> <span class="identifier">allocator_type</span> <span class="special">&gt;</span><span class="special">::</span><span class="identifier">const_reference</span> <a name="boost.container.multimap.const_reference"></a><span class="identifier">const_reference</span><span class="special">;</span>
50  <span class="keyword">typedef</span> <a class="link" href="allocator_traits.html" title="Struct template allocator_traits">boost::container::allocator_traits</a><span class="special">&lt;</span> <span class="identifier">allocator_type</span> <span class="special">&gt;</span><span class="special">::</span><span class="identifier">size_type</span>       <a name="boost.container.multimap.size_type"></a><span class="identifier">size_type</span><span class="special">;</span>
51  <span class="keyword">typedef</span> <a class="link" href="allocator_traits.html" title="Struct template allocator_traits">boost::container::allocator_traits</a><span class="special">&lt;</span> <span class="identifier">allocator_type</span> <span class="special">&gt;</span><span class="special">::</span><span class="identifier">difference_type</span> <a name="boost.container.multimap.difference_type"></a><span class="identifier">difference_type</span><span class="special">;</span>
52  <span class="keyword">typedef</span> <span class="identifier">implementation_defined</span>                                                <a name="boost.container.multimap.stored_allocator_type"></a><span class="identifier">stored_allocator_type</span><span class="special">;</span>
53  <span class="keyword">typedef</span> <span class="identifier">implementation_defined</span>                                                <a name="boost.container.multimap.value_compare"></a><span class="identifier">value_compare</span><span class="special">;</span>
54  <span class="keyword">typedef</span> <span class="identifier">Compare</span>                                                               <a name="boost.container.multimap.key_compare"></a><span class="identifier">key_compare</span><span class="special">;</span>
55  <span class="keyword">typedef</span> <span class="identifier">implementation_defined</span>                                                <a name="boost.container.multimap.iterator"></a><span class="identifier">iterator</span><span class="special">;</span>
56  <span class="keyword">typedef</span> <span class="identifier">implementation_defined</span>                                                <a name="boost.container.multimap.const_iterator"></a><span class="identifier">const_iterator</span><span class="special">;</span>
57  <span class="keyword">typedef</span> <span class="identifier">implementation_defined</span>                                                <a name="boost.container.multimap.reverse_iterator"></a><span class="identifier">reverse_iterator</span><span class="special">;</span>
58  <span class="keyword">typedef</span> <span class="identifier">implementation_defined</span>                                                <a name="boost.container.multimap.const_reverse_iterator"></a><span class="identifier">const_reverse_iterator</span><span class="special">;</span>
59  <span class="keyword">typedef</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span> <span class="identifier">key_type</span><span class="special">,</span> <span class="identifier">mapped_type</span> <span class="special">&gt;</span>                                    <a name="boost.container.multimap.nonconst_value_type"></a><span class="identifier">nonconst_value_type</span><span class="special">;</span>
60  <span class="keyword">typedef</span> <span class="identifier">implementation_defined</span>                                                <a name="boost.container.multimap.movable_value_type"></a><span class="identifier">movable_value_type</span><span class="special">;</span>
61  <span class="keyword">typedef</span> <span class="identifier">implementation_defined</span>                                                <a name="boost.container.multimap.node_type"></a><span class="identifier">node_type</span><span class="special">;</span>
62
63  <span class="comment">// <a class="link" href="multimap.html#boost.container.multimapconstruct-copy-destruct">construct/copy/destruct</a></span>
64  <a class="link" href="multimap.html#idm45641213293744-bb"><span class="identifier">multimap</span></a><span class="special">(</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">(</span><span class="identifier">dtl</span><span class="special">::</span><span class="identifier">is_nothrow_default_constructible</span><span class="special">&lt;</span> <span class="identifier">allocator_type</span> <span class="special">&gt;</span><span class="special">::</span><span class="identifier">value</span> <span class="special">&amp;&amp;</span><span class="identifier">dtl</span><span class="special">::</span><span class="identifier">is_nothrow_default_constructible</span><span class="special">&lt;</span> <span class="identifier">Compare</span> <span class="special">&gt;</span><span class="special">::</span><span class="identifier">value</span><span class="special">)</span><span class="special">)</span><span class="special">;</span>
65  <span class="keyword">explicit</span> <a class="link" href="multimap.html#idm45641213291232-bb"><span class="identifier">multimap</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">allocator_type</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
66  <span class="keyword">explicit</span> <a class="link" href="multimap.html#idm45641213288096-bb"><span class="identifier">multimap</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">Compare</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
67  <a class="link" href="multimap.html#idm45641213284976-bb"><span class="identifier">multimap</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">Compare</span> <span class="special">&amp;</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">allocator_type</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
68  <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> InputIterator<span class="special">&gt;</span> <a class="link" href="multimap.html#idm45641213281424-bb"><span class="identifier">multimap</span></a><span class="special">(</span><span class="identifier">InputIterator</span><span class="special">,</span> <span class="identifier">InputIterator</span><span class="special">)</span><span class="special">;</span>
69  <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> InputIterator<span class="special">&gt;</span>
70    <a class="link" href="multimap.html#idm45641213276912-bb"><span class="identifier">multimap</span></a><span class="special">(</span><span class="identifier">InputIterator</span><span class="special">,</span> <span class="identifier">InputIterator</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">allocator_type</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
71  <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> InputIterator<span class="special">&gt;</span>
72    <a class="link" href="multimap.html#idm45641213271680-bb"><span class="identifier">multimap</span></a><span class="special">(</span><span class="identifier">InputIterator</span><span class="special">,</span> <span class="identifier">InputIterator</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">Compare</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
73  <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> InputIterator<span class="special">&gt;</span>
74    <a class="link" href="multimap.html#idm45641213266432-bb"><span class="identifier">multimap</span></a><span class="special">(</span><span class="identifier">InputIterator</span><span class="special">,</span> <span class="identifier">InputIterator</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">Compare</span> <span class="special">&amp;</span><span class="special">,</span>
75             <span class="keyword">const</span> <span class="identifier">allocator_type</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
76  <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> InputIterator<span class="special">&gt;</span>
77    <a class="link" href="multimap.html#idm45641213260496-bb"><span class="identifier">multimap</span></a><span class="special">(</span><a class="link" href="ordered_range_t.html" title="Struct ordered_range_t">ordered_range_t</a><span class="special">,</span> <span class="identifier">InputIterator</span><span class="special">,</span> <span class="identifier">InputIterator</span><span class="special">)</span><span class="special">;</span>
78  <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> InputIterator<span class="special">&gt;</span>
79    <a class="link" href="multimap.html#idm45641213253424-bb"><span class="identifier">multimap</span></a><span class="special">(</span><a class="link" href="ordered_range_t.html" title="Struct ordered_range_t">ordered_range_t</a><span class="special">,</span> <span class="identifier">InputIterator</span><span class="special">,</span> <span class="identifier">InputIterator</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">Compare</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
80  <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> InputIterator<span class="special">&gt;</span>
81    <a class="link" href="multimap.html#idm45641213245632-bb"><span class="identifier">multimap</span></a><span class="special">(</span><a class="link" href="ordered_range_t.html" title="Struct ordered_range_t">ordered_range_t</a><span class="special">,</span> <span class="identifier">InputIterator</span><span class="special">,</span> <span class="identifier">InputIterator</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">Compare</span> <span class="special">&amp;</span><span class="special">,</span>
82             <span class="keyword">const</span> <span class="identifier">allocator_type</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
83  <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> InputIterator<span class="special">&gt;</span>
84    <a class="link" href="multimap.html#idm45641213237136-bb"><span class="identifier">multimap</span></a><span class="special">(</span><a class="link" href="ordered_range_t.html" title="Struct ordered_range_t">ordered_range_t</a><span class="special">,</span> <span class="identifier">InputIterator</span><span class="special">,</span> <span class="identifier">InputIterator</span><span class="special">,</span>
85             <span class="keyword">const</span> <span class="identifier">allocator_type</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
86  <a class="link" href="multimap.html#idm45641213229344-bb"><span class="identifier">multimap</span></a><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">initializer_list</span><span class="special">&lt;</span> <span class="identifier">value_type</span> <span class="special">&gt;</span><span class="special">)</span><span class="special">;</span>
87  <a class="link" href="multimap.html#idm45641213226320-bb"><span class="identifier">multimap</span></a><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">initializer_list</span><span class="special">&lt;</span> <span class="identifier">value_type</span> <span class="special">&gt;</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">allocator_type</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
88  <a class="link" href="multimap.html#idm45641213222576-bb"><span class="identifier">multimap</span></a><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">initializer_list</span><span class="special">&lt;</span> <span class="identifier">value_type</span> <span class="special">&gt;</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">Compare</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
89  <a class="link" href="multimap.html#idm45641213218832-bb"><span class="identifier">multimap</span></a><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">initializer_list</span><span class="special">&lt;</span> <span class="identifier">value_type</span> <span class="special">&gt;</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">Compare</span> <span class="special">&amp;</span><span class="special">,</span>
90           <span class="keyword">const</span> <span class="identifier">allocator_type</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
91  <a class="link" href="multimap.html#idm45641213214384-bb"><span class="identifier">multimap</span></a><span class="special">(</span><a class="link" href="ordered_range_t.html" title="Struct ordered_range_t">ordered_range_t</a><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">initializer_list</span><span class="special">&lt;</span> <span class="identifier">value_type</span> <span class="special">&gt;</span><span class="special">)</span><span class="special">;</span>
92  <a class="link" href="multimap.html#idm45641213208832-bb"><span class="identifier">multimap</span></a><span class="special">(</span><a class="link" href="ordered_range_t.html" title="Struct ordered_range_t">ordered_range_t</a><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">initializer_list</span><span class="special">&lt;</span> <span class="identifier">value_type</span> <span class="special">&gt;</span><span class="special">,</span>
93           <span class="keyword">const</span> <span class="identifier">Compare</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
94  <a class="link" href="multimap.html#idm45641213202560-bb"><span class="identifier">multimap</span></a><span class="special">(</span><a class="link" href="ordered_range_t.html" title="Struct ordered_range_t">ordered_range_t</a><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">initializer_list</span><span class="special">&lt;</span> <span class="identifier">value_type</span> <span class="special">&gt;</span><span class="special">,</span>
95           <span class="keyword">const</span> <span class="identifier">Compare</span> <span class="special">&amp;</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">allocator_type</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
96  <a class="link" href="multimap.html#idm45641213195632-bb"><span class="identifier">multimap</span></a><span class="special">(</span><span class="keyword">const</span> <a class="link" href="multimap.html" title="Class template multimap">multimap</a> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
97  <a class="link" href="multimap.html#idm45641213192368-bb"><span class="identifier">multimap</span></a><span class="special">(</span><a class="link" href="multimap.html" title="Class template multimap">multimap</a> <span class="special">&amp;&amp;</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">(</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">container</span><span class="special">::</span><span class="identifier">dtl</span><span class="special">::</span><span class="identifier">is_nothrow_move_constructible</span><span class="special">&lt;</span> <span class="identifier">Compare</span> <span class="special">&gt;</span><span class="special">::</span><span class="identifier">value</span><span class="special">)</span><span class="special">)</span><span class="special">;</span>
98  <a class="link" href="multimap.html#idm45641213188048-bb"><span class="identifier">multimap</span></a><span class="special">(</span><span class="keyword">const</span> <a class="link" href="multimap.html" title="Class template multimap">multimap</a> <span class="special">&amp;</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">allocator_type</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
99  <a class="link" href="multimap.html#idm45641213184096-bb"><span class="identifier">multimap</span></a><span class="special">(</span><a class="link" href="multimap.html" title="Class template multimap">multimap</a> <span class="special">&amp;&amp;</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">allocator_type</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
100  <a class="link" href="multimap.html" title="Class template multimap">multimap</a> <span class="special">&amp;</span> <a class="link" href="multimap.html#idm45641213179488-bb"><span class="keyword">operator</span><span class="special">=</span></a><span class="special">(</span><span class="keyword">const</span> <a class="link" href="multimap.html" title="Class template multimap">multimap</a> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
101  <a class="link" href="multimap.html" title="Class template multimap">multimap</a> <span class="special">&amp;</span> <a class="link" href="multimap.html#idm45641213175648-bb"><span class="keyword">operator</span><span class="special">=</span></a><span class="special">(</span><a class="link" href="multimap.html" title="Class template multimap">multimap</a> <span class="special">&amp;&amp;</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">(</span><span class="special">(</span><span class="identifier">allocator_traits_type</span><span class="special">::</span><span class="identifier">propagate_on_container_move_assignment</span><span class="special">::</span><span class="identifier">value</span><span class="special">||</span><span class="identifier">allocator_traits_type</span><span class="special">::</span><span class="identifier">is_always_equal</span><span class="special">::</span><span class="identifier">value</span><span class="special">)</span> <span class="special">&amp;&amp;</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">container</span><span class="special">::</span><span class="identifier">dtl</span><span class="special">::</span><span class="identifier">is_nothrow_move_assignable</span><span class="special">&lt;</span> <span class="identifier">Compare</span> <span class="special">&gt;</span><span class="special">::</span><span class="identifier">value</span><span class="special">)</span><span class="special">)</span><span class="special">;</span>
102  <a class="link" href="multimap.html" title="Class template multimap">multimap</a> <span class="special">&amp;</span> <a class="link" href="multimap.html#idm45641213171536-bb"><span class="keyword">operator</span><span class="special">=</span></a><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">initializer_list</span><span class="special">&lt;</span> <span class="identifier">value_type</span> <span class="special">&gt;</span><span class="special">)</span><span class="special">;</span>
103
104  <span class="comment">// <a class="link" href="multimap.html#idm45641213589616-bb">public member functions</a></span>
105   <a class="link" href="multimap.html#idm45641213589056-bb"><span class="identifier">BOOST_STATIC_ASSERT</span></a><span class="special">(</span><span class="special">(</span><span class="identifier">dtl</span><span class="special">::</span><span class="identifier">is_same</span><span class="special">&lt;</span> <span class="keyword">typename</span> <span class="identifier">allocator_type</span><span class="special">::</span><span class="identifier">value_type</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span> <span class="keyword">const</span> <span class="identifier">Key</span><span class="special">,</span> <span class="identifier">T</span> <span class="special">&gt;</span> <span class="special">&gt;</span><span class="special">::</span><span class="identifier">value</span><span class="special">)</span><span class="special">)</span><span class="special">;</span>
106  <span class="identifier">allocator_type</span> <a class="link" href="multimap.html#idm45641213587616-bb"><span class="identifier">get_allocator</span></a><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
107  <span class="identifier">stored_allocator_type</span> <span class="special">&amp;</span> <a class="link" href="multimap.html#idm45641213584608-bb"><span class="identifier">get_stored_allocator</span></a><span class="special">(</span><span class="special">)</span><span class="special">;</span>
108  <span class="keyword">const</span> <span class="identifier">stored_allocator_type</span> <span class="special">&amp;</span> <a class="link" href="multimap.html#idm45641213580192-bb"><span class="identifier">get_stored_allocator</span></a><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
109  <span class="identifier">iterator</span> <a class="link" href="multimap.html#idm45641213575488-bb"><span class="identifier">begin</span></a><span class="special">(</span><span class="special">)</span><span class="special">;</span>
110  <span class="identifier">const_iterator</span> <a class="link" href="multimap.html#idm45641213571920-bb"><span class="identifier">begin</span></a><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
111  <span class="identifier">const_iterator</span> <a class="link" href="multimap.html#idm45641213568064-bb"><span class="identifier">cbegin</span></a><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
112  <span class="identifier">iterator</span> <a class="link" href="multimap.html#idm45641213564208-bb"><span class="identifier">end</span></a><span class="special">(</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>
113  <span class="identifier">const_iterator</span> <a class="link" href="multimap.html#idm45641213560384-bb"><span class="identifier">end</span></a><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span>
114  <span class="identifier">const_iterator</span> <a class="link" href="multimap.html#idm45641213556560-bb"><span class="identifier">cend</span></a><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span>
115  <span class="identifier">reverse_iterator</span> <a class="link" href="multimap.html#idm45641213552736-bb"><span class="identifier">rbegin</span></a><span class="special">(</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>
116  <span class="identifier">const_reverse_iterator</span> <a class="link" href="multimap.html#idm45641213548880-bb"><span class="identifier">rbegin</span></a><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span>
117  <span class="identifier">const_reverse_iterator</span> <a class="link" href="multimap.html#idm45641213545024-bb"><span class="identifier">crbegin</span></a><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span>
118  <span class="identifier">reverse_iterator</span> <a class="link" href="multimap.html#idm45641213541168-bb"><span class="identifier">rend</span></a><span class="special">(</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>
119  <span class="identifier">const_reverse_iterator</span> <a class="link" href="multimap.html#idm45641213537312-bb"><span class="identifier">rend</span></a><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span>
120  <span class="identifier">const_reverse_iterator</span> <a class="link" href="multimap.html#idm45641213533456-bb"><span class="identifier">crend</span></a><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span>
121  <span class="keyword">bool</span> <a class="link" href="multimap.html#idm45641213529600-bb"><span class="identifier">empty</span></a><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
122  <span class="identifier">size_type</span> <a class="link" href="multimap.html#idm45641213525776-bb"><span class="identifier">size</span></a><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
123  <span class="identifier">size_type</span> <a class="link" href="multimap.html#idm45641213521936-bb"><span class="identifier">max_size</span></a><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
124  <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span><span class="special">...</span> Args<span class="special">&gt;</span> <span class="identifier">iterator</span> <a class="link" href="multimap.html#idm45641213518112-bb"><span class="identifier">emplace</span></a><span class="special">(</span><span class="identifier">Args</span> <span class="special">&amp;&amp;</span><span class="special">...</span><span class="special">)</span><span class="special">;</span>
125  <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span><span class="special">...</span> Args<span class="special">&gt;</span> <span class="identifier">iterator</span> <a class="link" href="multimap.html#idm45641213512496-bb"><span class="identifier">emplace_hint</span></a><span class="special">(</span><span class="identifier">const_iterator</span><span class="special">,</span> <span class="identifier">Args</span> <span class="special">&amp;&amp;</span><span class="special">...</span><span class="special">)</span><span class="special">;</span>
126  <span class="identifier">iterator</span> <a class="link" href="multimap.html#idm45641213506192-bb"><span class="identifier">insert</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">value_type</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
127  <span class="identifier">iterator</span> <a class="link" href="multimap.html#idm45641213502768-bb"><span class="identifier">insert</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">nonconst_value_type</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
128  <span class="identifier">iterator</span> <a class="link" href="multimap.html#idm45641213499296-bb"><span class="identifier">insert</span></a><span class="special">(</span><span class="identifier">nonconst_value_type</span> <span class="special">&amp;&amp;</span><span class="special">)</span><span class="special">;</span>
129  <span class="identifier">iterator</span> <a class="link" href="multimap.html#idm45641213495840-bb"><span class="identifier">insert</span></a><span class="special">(</span><span class="identifier">movable_value_type</span> <span class="special">&amp;&amp;</span><span class="special">)</span><span class="special">;</span>
130  <span class="identifier">iterator</span> <a class="link" href="multimap.html#idm45641213492384-bb"><span class="identifier">insert</span></a><span class="special">(</span><span class="identifier">const_iterator</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">value_type</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
131  <span class="identifier">iterator</span> <a class="link" href="multimap.html#idm45641213487264-bb"><span class="identifier">insert</span></a><span class="special">(</span><span class="identifier">const_iterator</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">nonconst_value_type</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
132  <span class="identifier">iterator</span> <a class="link" href="multimap.html#idm45641213482112-bb"><span class="identifier">insert</span></a><span class="special">(</span><span class="identifier">const_iterator</span><span class="special">,</span> <span class="identifier">nonconst_value_type</span> <span class="special">&amp;&amp;</span><span class="special">)</span><span class="special">;</span>
133  <span class="identifier">iterator</span> <a class="link" href="multimap.html#idm45641213476976-bb"><span class="identifier">insert</span></a><span class="special">(</span><span class="identifier">const_iterator</span><span class="special">,</span> <span class="identifier">movable_value_type</span> <span class="special">&amp;&amp;</span><span class="special">)</span><span class="special">;</span>
134  <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> InputIterator<span class="special">&gt;</span> <span class="keyword">void</span> <a class="link" href="multimap.html#idm45641213471840-bb"><span class="identifier">insert</span></a><span class="special">(</span><span class="identifier">InputIterator</span><span class="special">,</span> <span class="identifier">InputIterator</span><span class="special">)</span><span class="special">;</span>
135  <span class="keyword">void</span> <a class="link" href="multimap.html#idm45641213465984-bb"><span class="identifier">insert</span></a><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">initializer_list</span><span class="special">&lt;</span> <span class="identifier">value_type</span> <span class="special">&gt;</span><span class="special">)</span><span class="special">;</span>
136  <span class="identifier">iterator</span> <a class="link" href="multimap.html#idm45641213462496-bb"><span class="identifier">insert</span></a><span class="special">(</span><span class="identifier">node_type</span> <span class="special">&amp;&amp;</span><span class="special">)</span><span class="special">;</span>
137  <span class="identifier">iterator</span> <a class="link" href="multimap.html#idm45641213457952-bb"><span class="identifier">insert</span></a><span class="special">(</span><span class="identifier">const_iterator</span><span class="special">,</span> <span class="identifier">node_type</span> <span class="special">&amp;&amp;</span><span class="special">)</span><span class="special">;</span>
138  <span class="identifier">iterator</span> <a class="link" href="multimap.html#idm45641213453312-bb"><span class="identifier">erase</span></a><span class="special">(</span><span class="identifier">const_iterator</span><span class="special">)</span><span class="special">;</span>
139  <span class="identifier">size_type</span> <a class="link" href="multimap.html#idm45641213448944-bb"><span class="identifier">erase</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">key_type</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
140  <span class="identifier">iterator</span> <a class="link" href="multimap.html#idm45641213444640-bb"><span class="identifier">erase</span></a><span class="special">(</span><span class="identifier">const_iterator</span><span class="special">,</span> <span class="identifier">const_iterator</span><span class="special">)</span><span class="special">;</span>
141  <span class="identifier">node_type</span> <a class="link" href="multimap.html#idm45641213439664-bb"><span class="identifier">extract</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">key_type</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
142  <span class="identifier">node_type</span> <a class="link" href="multimap.html#idm45641213435344-bb"><span class="identifier">extract</span></a><span class="special">(</span><span class="identifier">const_iterator</span><span class="special">)</span><span class="special">;</span>
143  <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> C2<span class="special">&gt;</span>
144    <span class="keyword">void</span> <a class="link" href="multimap.html#idm45641213431056-bb"><span class="identifier">merge</span></a><span class="special">(</span><a class="link" href="multimap.html" title="Class template multimap">multimap</a><span class="special">&lt;</span> <span class="identifier">Key</span><span class="special">,</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">C2</span><span class="special">,</span> <span class="identifier">Allocator</span><span class="special">,</span> <span class="identifier">Options</span> <span class="special">&gt;</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
145  <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> C2<span class="special">&gt;</span>
146    <span class="keyword">void</span> <a class="link" href="multimap.html#idm45641213423568-bb"><span class="identifier">merge</span></a><span class="special">(</span><a class="link" href="multimap.html" title="Class template multimap">multimap</a><span class="special">&lt;</span> <span class="identifier">Key</span><span class="special">,</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">C2</span><span class="special">,</span> <span class="identifier">Allocator</span><span class="special">,</span> <span class="identifier">Options</span> <span class="special">&gt;</span> <span class="special">&amp;&amp;</span><span class="special">)</span><span class="special">;</span>
147  <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> C2<span class="special">&gt;</span> <span class="keyword">void</span> <a class="link" href="multimap.html#idm45641213416080-bb"><span class="identifier">merge</span></a><span class="special">(</span><a class="link" href="map.html" title="Class template map">map</a><span class="special">&lt;</span> <span class="identifier">Key</span><span class="special">,</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">C2</span><span class="special">,</span> <span class="identifier">Allocator</span><span class="special">,</span> <span class="identifier">Options</span> <span class="special">&gt;</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
148  <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> C2<span class="special">&gt;</span> <span class="keyword">void</span> <a class="link" href="multimap.html#idm45641213408592-bb"><span class="identifier">merge</span></a><span class="special">(</span><a class="link" href="map.html" title="Class template map">map</a><span class="special">&lt;</span> <span class="identifier">Key</span><span class="special">,</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">C2</span><span class="special">,</span> <span class="identifier">Allocator</span><span class="special">,</span> <span class="identifier">Options</span> <span class="special">&gt;</span> <span class="special">&amp;&amp;</span><span class="special">)</span><span class="special">;</span>
149  <span class="keyword">void</span> <a class="link" href="multimap.html#idm45641213401104-bb"><span class="identifier">swap</span></a><span class="special">(</span><a class="link" href="multiset.html" title="Class template multiset">multiset</a> <span class="special">&amp;</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">(</span><span class="identifier">allocator_traits_type</span><span class="special">::</span><span class="identifier">is_always_equal</span><span class="special">::</span><span class="identifier">value</span> <span class="special">&amp;&amp;</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">container</span><span class="special">::</span><span class="identifier">dtl</span><span class="special">::</span><span class="identifier">is_nothrow_swappable</span><span class="special">&lt;</span> <span class="identifier">Compare</span> <span class="special">&gt;</span><span class="special">::</span><span class="identifier">value</span><span class="special">)</span><span class="special">)</span><span class="special">;</span>
150  <span class="keyword">void</span> <a class="link" href="multimap.html#idm45641213396208-bb"><span class="identifier">clear</span></a><span class="special">(</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>
151  <span class="identifier">key_compare</span> <a class="link" href="multimap.html#idm45641213392416-bb"><span class="identifier">key_comp</span></a><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
152  <span class="identifier">value_compare</span> <a class="link" href="multimap.html#idm45641213389424-bb"><span class="identifier">value_comp</span></a><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
153  <span class="identifier">iterator</span> <a class="link" href="multimap.html#idm45641213386416-bb"><span class="identifier">find</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">key_type</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
154  <span class="identifier">const_iterator</span> <a class="link" href="multimap.html#idm45641213382960-bb"><span class="identifier">find</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">key_type</span> <span class="special">&amp;</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
155  <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> K<span class="special">&gt;</span> <span class="identifier">iterator</span> <a class="link" href="multimap.html#idm45641213379232-bb"><span class="identifier">find</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">K</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
156  <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> K<span class="special">&gt;</span> <span class="identifier">const_iterator</span> <a class="link" href="multimap.html#idm45641213374016-bb"><span class="identifier">find</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">K</span> <span class="special">&amp;</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
157  <span class="identifier">size_type</span> <a class="link" href="multimap.html#idm45641213368528-bb"><span class="identifier">count</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">key_type</span> <span class="special">&amp;</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
158  <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> K<span class="special">&gt;</span> <span class="identifier">size_type</span> <a class="link" href="multimap.html#idm45641213364864-bb"><span class="identifier">count</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">K</span> <span class="special">&amp;</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
159  <span class="keyword">bool</span> <a class="link" href="multimap.html#idm45641213359440-bb"><span class="identifier">contains</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">key_type</span> <span class="special">&amp;</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
160  <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> K<span class="special">&gt;</span> <span class="keyword">bool</span> <a class="link" href="multimap.html#idm45641213355728-bb"><span class="identifier">contains</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">K</span> <span class="special">&amp;</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
161  <span class="identifier">iterator</span> <a class="link" href="multimap.html#idm45641213350256-bb"><span class="identifier">lower_bound</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">key_type</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
162  <span class="identifier">const_iterator</span> <a class="link" href="multimap.html#idm45641213346800-bb"><span class="identifier">lower_bound</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">key_type</span> <span class="special">&amp;</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
163  <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> K<span class="special">&gt;</span> <span class="identifier">iterator</span> <a class="link" href="multimap.html#idm45641213343072-bb"><span class="identifier">lower_bound</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">K</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
164  <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> K<span class="special">&gt;</span> <span class="identifier">const_iterator</span> <a class="link" href="multimap.html#idm45641213337856-bb"><span class="identifier">lower_bound</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">K</span> <span class="special">&amp;</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
165  <span class="identifier">iterator</span> <a class="link" href="multimap.html#idm45641213332368-bb"><span class="identifier">upper_bound</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">key_type</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
166  <span class="identifier">const_iterator</span> <a class="link" href="multimap.html#idm45641213328912-bb"><span class="identifier">upper_bound</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">key_type</span> <span class="special">&amp;</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
167  <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> K<span class="special">&gt;</span> <span class="identifier">iterator</span> <a class="link" href="multimap.html#idm45641213325184-bb"><span class="identifier">upper_bound</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">K</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
168  <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> K<span class="special">&gt;</span> <span class="identifier">const_iterator</span> <a class="link" href="multimap.html#idm45641213319968-bb"><span class="identifier">upper_bound</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">K</span> <span class="special">&amp;</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
169  <span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span> <span class="identifier">iterator</span><span class="special">,</span> <span class="identifier">iterator</span> <span class="special">&gt;</span> <a class="link" href="multimap.html#idm45641213314480-bb"><span class="identifier">equal_range</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">key_type</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
170  <span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span> <span class="identifier">const_iterator</span><span class="special">,</span> <span class="identifier">const_iterator</span> <span class="special">&gt;</span>
171  <a class="link" href="multimap.html#idm45641213311040-bb"><span class="identifier">equal_range</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">key_type</span> <span class="special">&amp;</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
172  <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> K<span class="special">&gt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span> <span class="identifier">iterator</span><span class="special">,</span> <span class="identifier">iterator</span> <span class="special">&gt;</span> <a class="link" href="multimap.html#idm45641213307312-bb"><span class="identifier">equal_range</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">K</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
173  <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> K<span class="special">&gt;</span>
174    <span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span> <span class="identifier">const_iterator</span><span class="special">,</span> <span class="identifier">const_iterator</span> <span class="special">&gt;</span> <a class="link" href="multimap.html#idm45641213302112-bb"><span class="identifier">equal_range</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">K</span> <span class="special">&amp;</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
175  <span class="keyword">void</span> <a class="link" href="multimap.html#idm45641213296624-bb"><span class="identifier">rebalance</span></a><span class="special">(</span><span class="special">)</span><span class="special">;</span>
176
177  <span class="comment">// <a class="link" href="multimap.html#idm45641213168976-bb">friend functions</a></span>
178  <span class="keyword">friend</span> <span class="keyword">bool</span> <a class="link" href="multimap.html#idm45641213168416-bb"><span class="keyword">operator</span><span class="special">==</span></a><span class="special">(</span><span class="keyword">const</span> <a class="link" href="multimap.html" title="Class template multimap">multimap</a> <span class="special">&amp;</span><span class="special">,</span> <span class="keyword">const</span> <a class="link" href="multimap.html" title="Class template multimap">multimap</a> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
179  <span class="keyword">friend</span> <span class="keyword">bool</span> <a class="link" href="multimap.html#idm45641213163424-bb"><span class="keyword">operator</span><span class="special">!=</span></a><span class="special">(</span><span class="keyword">const</span> <a class="link" href="multimap.html" title="Class template multimap">multimap</a> <span class="special">&amp;</span><span class="special">,</span> <span class="keyword">const</span> <a class="link" href="multimap.html" title="Class template multimap">multimap</a> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
180  <span class="keyword">friend</span> <span class="keyword">bool</span> <a class="link" href="multimap.html#idm45641213158432-bb"><span class="keyword">operator</span><span class="special">&lt;</span></a><span class="special">(</span><span class="keyword">const</span> <a class="link" href="multimap.html" title="Class template multimap">multimap</a> <span class="special">&amp;</span><span class="special">,</span> <span class="keyword">const</span> <a class="link" href="multimap.html" title="Class template multimap">multimap</a> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
181  <span class="keyword">friend</span> <span class="keyword">bool</span> <a class="link" href="multimap.html#idm45641213153440-bb"><span class="keyword">operator</span><span class="special">&gt;</span></a><span class="special">(</span><span class="keyword">const</span> <a class="link" href="multimap.html" title="Class template multimap">multimap</a> <span class="special">&amp;</span><span class="special">,</span> <span class="keyword">const</span> <a class="link" href="multimap.html" title="Class template multimap">multimap</a> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
182  <span class="keyword">friend</span> <span class="keyword">bool</span> <a class="link" href="multimap.html#idm45641213148448-bb"><span class="keyword">operator</span><span class="special">&lt;=</span></a><span class="special">(</span><span class="keyword">const</span> <a class="link" href="multimap.html" title="Class template multimap">multimap</a> <span class="special">&amp;</span><span class="special">,</span> <span class="keyword">const</span> <a class="link" href="multimap.html" title="Class template multimap">multimap</a> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
183  <span class="keyword">friend</span> <span class="keyword">bool</span> <a class="link" href="multimap.html#idm45641213143440-bb"><span class="keyword">operator</span><span class="special">&gt;=</span></a><span class="special">(</span><span class="keyword">const</span> <a class="link" href="multimap.html" title="Class template multimap">multimap</a> <span class="special">&amp;</span><span class="special">,</span> <span class="keyword">const</span> <a class="link" href="multimap.html" title="Class template multimap">multimap</a> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
184  <span class="keyword">friend</span> <span class="keyword">void</span> <a class="link" href="multimap.html#idm45641213138432-bb"><span class="identifier">swap</span></a><span class="special">(</span><a class="link" href="multimap.html" title="Class template multimap">multimap</a> <span class="special">&amp;</span><span class="special">,</span> <a class="link" href="multimap.html" title="Class template multimap">multimap</a> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
185<span class="special">}</span><span class="special">;</span></pre></div>
186<div class="refsect1">
187<a name="id-1.3.10.14.14.4.4"></a><h2>Description</h2>
188<p>A multimap is a kind of associative container that supports equivalent keys (possibly containing multiple copies of the same key value) and provides for fast retrieval of values of another type T based on the keys. The multimap class supports bidirectional iterators.</p>
189<p>A multimap satisfies all of the requirements of a container and of a reversible container and of an associative container. The <code class="computeroutput">value_type</code> stored by this container is the value_type is std::pair&lt;const Key, T&gt;.</p>
190<p>
191</p>
192<div class="refsect2">
193<a name="id-1.3.10.14.14.4.4.5"></a><h3>Template Parameters</h3>
194<div class="orderedlist"><ol class="orderedlist" type="1">
195<li class="listitem">
196<pre class="literallayout"><span class="keyword">typename</span> Key</pre>
197<p>is the key_type of the map </p>
198</li>
199<li class="listitem"><pre class="literallayout"><span class="keyword">typename</span> T</pre></li>
200<li class="listitem">
201<pre class="literallayout"><span class="keyword">typename</span> Compare <span class="special">=</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">less</span><span class="special">&lt;</span><span class="identifier">Key</span><span class="special">&gt;</span></pre>
202<p>is the ordering function for Keys (e.g. <span class="emphasis"><em>std::less&lt;Key&gt;</em></span>). </p>
203</li>
204<li class="listitem">
205<pre class="literallayout"><span class="keyword">typename</span> Allocator <span class="special">=</span> <a class="link" href="new_allocator.html" title="Class template new_allocator">new_allocator</a><span class="special">&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span> <span class="keyword">const</span> <span class="identifier">Key</span><span class="special">,</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="special">&gt;</span></pre>
206<p>is the allocator to allocate the <code class="computeroutput">value_type</code>s (e.g. <span class="emphasis"><em>allocator&lt; std::pair&lt;const Key, T&gt; &gt; </em></span>). </p>
207</li>
208<li class="listitem">
209<pre class="literallayout"><span class="keyword">typename</span> Options <span class="special">=</span> <span class="identifier">tree_assoc_defaults</span></pre>
210<p>is an packed option type generated using using <code class="computeroutput"><a class="link" href="tree_assoc_options.html" title="Struct template tree_assoc_options">boost::container::tree_assoc_options</a></code>. </p>
211</li>
212</ol></div>
213</div>
214<div class="refsect2">
215<a name="id-1.3.10.14.14.4.4.6"></a><h3>
216<a name="boost.container.multimapconstruct-copy-destruct"></a><code class="computeroutput">multimap</code>
217        public
218       construct/copy/destruct</h3>
219<div class="orderedlist"><ol class="orderedlist" type="1">
220<li class="listitem">
221<pre class="literallayout"><a name="idm45641213293744-bb"></a><span class="identifier">multimap</span><span class="special">(</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">(</span><span class="identifier">dtl</span><span class="special">::</span><span class="identifier">is_nothrow_default_constructible</span><span class="special">&lt;</span> <span class="identifier">allocator_type</span> <span class="special">&gt;</span><span class="special">::</span><span class="identifier">value</span> <span class="special">&amp;&amp;</span><span class="identifier">dtl</span><span class="special">::</span><span class="identifier">is_nothrow_default_constructible</span><span class="special">&lt;</span> <span class="identifier">Compare</span> <span class="special">&gt;</span><span class="special">::</span><span class="identifier">value</span><span class="special">)</span><span class="special">)</span><span class="special">;</span></pre>
222<p><span class="bold"><strong>Effects</strong></span>: Default constructs an empty multimap.</p>
223<p><span class="bold"><strong>Complexity</strong></span>: Constant. </p>
224</li>
225<li class="listitem">
226<pre class="literallayout"><span class="keyword">explicit</span> <a name="idm45641213291232-bb"></a><span class="identifier">multimap</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">allocator_type</span> <span class="special">&amp;</span> a<span class="special">)</span><span class="special">;</span></pre>
227<p><span class="bold"><strong>Effects</strong></span>: Constructs an empty multimap using the specified allocator object and allocator.</p>
228<p><span class="bold"><strong>Complexity</strong></span>: Constant. </p>
229</li>
230<li class="listitem">
231<pre class="literallayout"><span class="keyword">explicit</span> <a name="idm45641213288096-bb"></a><span class="identifier">multimap</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">Compare</span> <span class="special">&amp;</span> comp<span class="special">)</span><span class="special">;</span></pre>
232<p><span class="bold"><strong>Effects</strong></span>: Constructs an empty multimap using the specified comparison.</p>
233<p><span class="bold"><strong>Complexity</strong></span>: Constant. </p>
234</li>
235<li class="listitem">
236<pre class="literallayout"><a name="idm45641213284976-bb"></a><span class="identifier">multimap</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">Compare</span> <span class="special">&amp;</span> comp<span class="special">,</span> <span class="keyword">const</span> <span class="identifier">allocator_type</span> <span class="special">&amp;</span> a<span class="special">)</span><span class="special">;</span></pre>
237<p><span class="bold"><strong>Effects</strong></span>: Constructs an empty multimap using the specified comparison and allocator.</p>
238<p><span class="bold"><strong>Complexity</strong></span>: Constant. </p>
239</li>
240<li class="listitem">
241<pre class="literallayout"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> InputIterator<span class="special">&gt;</span>
242  <a name="idm45641213281424-bb"></a><span class="identifier">multimap</span><span class="special">(</span><span class="identifier">InputIterator</span> first<span class="special">,</span> <span class="identifier">InputIterator</span> last<span class="special">)</span><span class="special">;</span></pre>
243<p><span class="bold"><strong>Effects</strong></span>: Constructs an empty multimap and inserts elements from the range [first ,last ).</p>
244<p><span class="bold"><strong>Complexity</strong></span>: Linear in N if the range [first ,last ) is already sorted using the predicate and otherwise N logN, where N is last - first. </p>
245</li>
246<li class="listitem">
247<pre class="literallayout"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> InputIterator<span class="special">&gt;</span>
248  <a name="idm45641213276912-bb"></a><span class="identifier">multimap</span><span class="special">(</span><span class="identifier">InputIterator</span> first<span class="special">,</span> <span class="identifier">InputIterator</span> last<span class="special">,</span> <span class="keyword">const</span> <span class="identifier">allocator_type</span> <span class="special">&amp;</span> a<span class="special">)</span><span class="special">;</span></pre>
249<p><span class="bold"><strong>Effects</strong></span>: Constructs an empty multimap using the specified allocator, and inserts elements from the range [first ,last ).</p>
250<p><span class="bold"><strong>Complexity</strong></span>: Linear in N if the range [first ,last ) is already sorted using the predicate and otherwise N logN, where N is last - first. </p>
251</li>
252<li class="listitem">
253<pre class="literallayout"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> InputIterator<span class="special">&gt;</span>
254  <a name="idm45641213271680-bb"></a><span class="identifier">multimap</span><span class="special">(</span><span class="identifier">InputIterator</span> first<span class="special">,</span> <span class="identifier">InputIterator</span> last<span class="special">,</span> <span class="keyword">const</span> <span class="identifier">Compare</span> <span class="special">&amp;</span> comp<span class="special">)</span><span class="special">;</span></pre>
255<p><span class="bold"><strong>Effects</strong></span>: Constructs an empty multimap using the specified comparison object and inserts elements from the range [first ,last ).</p>
256<p><span class="bold"><strong>Complexity</strong></span>: Linear in N if the range [first ,last ) is already sorted using the predicate and otherwise N logN, where N is last - first. </p>
257</li>
258<li class="listitem">
259<pre class="literallayout"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> InputIterator<span class="special">&gt;</span>
260  <a name="idm45641213266432-bb"></a><span class="identifier">multimap</span><span class="special">(</span><span class="identifier">InputIterator</span> first<span class="special">,</span> <span class="identifier">InputIterator</span> last<span class="special">,</span> <span class="keyword">const</span> <span class="identifier">Compare</span> <span class="special">&amp;</span> comp<span class="special">,</span>
261           <span class="keyword">const</span> <span class="identifier">allocator_type</span> <span class="special">&amp;</span> a<span class="special">)</span><span class="special">;</span></pre>
262<p><span class="bold"><strong>Effects</strong></span>: Constructs an empty multimap using the specified comparison object and allocator, and inserts elements from the range [first ,last ).</p>
263<p><span class="bold"><strong>Complexity</strong></span>: Linear in N if the range [first ,last ) is already sorted using the predicate and otherwise N logN, where N is last - first. </p>
264</li>
265<li class="listitem">
266<pre class="literallayout"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> InputIterator<span class="special">&gt;</span>
267  <a name="idm45641213260496-bb"></a><span class="identifier">multimap</span><span class="special">(</span><a class="link" href="ordered_range_t.html" title="Struct ordered_range_t">ordered_range_t</a><span class="special">,</span> <span class="identifier">InputIterator</span> first<span class="special">,</span> <span class="identifier">InputIterator</span> last<span class="special">)</span><span class="special">;</span></pre>
268<p><span class="bold"><strong>Effects</strong></span>: Constructs an empty multimap and inserts elements from the ordered range [first ,last). This function is more efficient than the normal range creation for ordered ranges.</p>
269<p><span class="bold"><strong>Requires</strong></span>: [first ,last) must be ordered according to the predicate.</p>
270<p><span class="bold"><strong>Complexity</strong></span>: Linear in N.</p>
271<p><span class="bold"><strong>Note</strong></span>: Non-standard extension. </p>
272</li>
273<li class="listitem">
274<pre class="literallayout"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> InputIterator<span class="special">&gt;</span>
275  <a name="idm45641213253424-bb"></a><span class="identifier">multimap</span><span class="special">(</span><a class="link" href="ordered_range_t.html" title="Struct ordered_range_t">ordered_range_t</a><span class="special">,</span> <span class="identifier">InputIterator</span> first<span class="special">,</span> <span class="identifier">InputIterator</span> last<span class="special">,</span>
276           <span class="keyword">const</span> <span class="identifier">Compare</span> <span class="special">&amp;</span> comp<span class="special">)</span><span class="special">;</span></pre>
277<p><span class="bold"><strong>Effects</strong></span>: Constructs an empty multimap using the specified comparison object and inserts elements from the ordered range [first ,last). This function is more efficient than the normal range creation for ordered ranges.</p>
278<p><span class="bold"><strong>Requires</strong></span>: [first ,last) must be ordered according to the predicate.</p>
279<p><span class="bold"><strong>Complexity</strong></span>: Linear in N.</p>
280<p><span class="bold"><strong>Note</strong></span>: Non-standard extension. </p>
281</li>
282<li class="listitem">
283<pre class="literallayout"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> InputIterator<span class="special">&gt;</span>
284  <a name="idm45641213245632-bb"></a><span class="identifier">multimap</span><span class="special">(</span><a class="link" href="ordered_range_t.html" title="Struct ordered_range_t">ordered_range_t</a><span class="special">,</span> <span class="identifier">InputIterator</span> first<span class="special">,</span> <span class="identifier">InputIterator</span> last<span class="special">,</span>
285           <span class="keyword">const</span> <span class="identifier">Compare</span> <span class="special">&amp;</span> comp<span class="special">,</span> <span class="keyword">const</span> <span class="identifier">allocator_type</span> <span class="special">&amp;</span> a<span class="special">)</span><span class="special">;</span></pre>
286<p><span class="bold"><strong>Effects</strong></span>: Constructs an empty multimap using the specified comparison object and allocator, and inserts elements from the ordered range [first ,last). This function is more efficient than the normal range creation for ordered ranges.</p>
287<p><span class="bold"><strong>Requires</strong></span>: [first ,last) must be ordered according to the predicate.</p>
288<p><span class="bold"><strong>Complexity</strong></span>: Linear in N.</p>
289<p><span class="bold"><strong>Note</strong></span>: Non-standard extension. </p>
290</li>
291<li class="listitem">
292<pre class="literallayout"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> InputIterator<span class="special">&gt;</span>
293  <a name="idm45641213237136-bb"></a><span class="identifier">multimap</span><span class="special">(</span><a class="link" href="ordered_range_t.html" title="Struct ordered_range_t">ordered_range_t</a><span class="special">,</span> <span class="identifier">InputIterator</span> first<span class="special">,</span> <span class="identifier">InputIterator</span> last<span class="special">,</span>
294           <span class="keyword">const</span> <span class="identifier">allocator_type</span> <span class="special">&amp;</span> a<span class="special">)</span><span class="special">;</span></pre>
295<p><span class="bold"><strong>Effects</strong></span>: Constructs an empty multimap using the specified allocator and inserts elements from the ordered range [first ,last). This function is more efficient than the normal range creation for ordered ranges.</p>
296<p><span class="bold"><strong>Requires</strong></span>: [first ,last) must be ordered according to the predicate.</p>
297<p><span class="bold"><strong>Complexity</strong></span>: Linear in N.</p>
298<p><span class="bold"><strong>Note</strong></span>: Non-standard extension. </p>
299</li>
300<li class="listitem">
301<pre class="literallayout"><a name="idm45641213229344-bb"></a><span class="identifier">multimap</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">initializer_list</span><span class="special">&lt;</span> <span class="identifier">value_type</span> <span class="special">&gt;</span> il<span class="special">)</span><span class="special">;</span></pre>
302<p><span class="bold"><strong>Effects</strong></span>: Constructs an empty multimap and and inserts elements from the range [il.begin(), il.end()).</p>
303<p><span class="bold"><strong>Complexity</strong></span>: Linear in N if the range [first ,last ) is already sorted using the predicate and otherwise N logN, where N is il.first() - il.end(). </p>
304</li>
305<li class="listitem">
306<pre class="literallayout"><a name="idm45641213226320-bb"></a><span class="identifier">multimap</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">initializer_list</span><span class="special">&lt;</span> <span class="identifier">value_type</span> <span class="special">&gt;</span> il<span class="special">,</span> <span class="keyword">const</span> <span class="identifier">allocator_type</span> <span class="special">&amp;</span> a<span class="special">)</span><span class="special">;</span></pre>
307<p><span class="bold"><strong>Effects</strong></span>: Constructs an empty multimap using the specified allocator, and inserts elements from the range [il.begin(), il.end()).</p>
308<p><span class="bold"><strong>Complexity</strong></span>: Linear in N if the range [first ,last ) is already sorted using the predicate and otherwise N logN, where N is il.first() - il.end(). </p>
309</li>
310<li class="listitem">
311<pre class="literallayout"><a name="idm45641213222576-bb"></a><span class="identifier">multimap</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">initializer_list</span><span class="special">&lt;</span> <span class="identifier">value_type</span> <span class="special">&gt;</span> il<span class="special">,</span> <span class="keyword">const</span> <span class="identifier">Compare</span> <span class="special">&amp;</span> comp<span class="special">)</span><span class="special">;</span></pre>
312<p><span class="bold"><strong>Effects</strong></span>: Constructs an empty multimap using the specified comparison object and inserts elements from the range [il.begin(), il.end()).</p>
313<p><span class="bold"><strong>Complexity</strong></span>: Linear in N if the range [first ,last ) is already sorted using the predicate and otherwise N logN, where N is il.first() - il.end(). </p>
314</li>
315<li class="listitem">
316<pre class="literallayout"><a name="idm45641213218832-bb"></a><span class="identifier">multimap</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">initializer_list</span><span class="special">&lt;</span> <span class="identifier">value_type</span> <span class="special">&gt;</span> il<span class="special">,</span> <span class="keyword">const</span> <span class="identifier">Compare</span> <span class="special">&amp;</span> comp<span class="special">,</span>
317         <span class="keyword">const</span> <span class="identifier">allocator_type</span> <span class="special">&amp;</span> a<span class="special">)</span><span class="special">;</span></pre>
318<p><span class="bold"><strong>Effects</strong></span>: Constructs an empty multimap using the specified comparison object and allocator, and inserts elements from the range [il.begin(), il.end()).</p>
319<p><span class="bold"><strong>Complexity</strong></span>: Linear in N if the range [first ,last ) is already sorted using the predicate and otherwise N logN, where N is il.first() - il.end(). </p>
320</li>
321<li class="listitem">
322<pre class="literallayout"><a name="idm45641213214384-bb"></a><span class="identifier">multimap</span><span class="special">(</span><a class="link" href="ordered_range_t.html" title="Struct ordered_range_t">ordered_range_t</a><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">initializer_list</span><span class="special">&lt;</span> <span class="identifier">value_type</span> <span class="special">&gt;</span> il<span class="special">)</span><span class="special">;</span></pre>
323<p><span class="bold"><strong>Effects</strong></span>: Constructs an empty map and inserts elements from the ordered range [il.begin(), il.end()). This function is more efficient than the normal range creation for ordered ranges.</p>
324<p><span class="bold"><strong>Requires</strong></span>: [il.begin(), il.end()) must be ordered according to the predicate.</p>
325<p><span class="bold"><strong>Complexity</strong></span>: Linear in N.</p>
326<p><span class="bold"><strong>Note</strong></span>: Non-standard extension. </p>
327</li>
328<li class="listitem">
329<pre class="literallayout"><a name="idm45641213208832-bb"></a><span class="identifier">multimap</span><span class="special">(</span><a class="link" href="ordered_range_t.html" title="Struct ordered_range_t">ordered_range_t</a><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">initializer_list</span><span class="special">&lt;</span> <span class="identifier">value_type</span> <span class="special">&gt;</span> il<span class="special">,</span>
330         <span class="keyword">const</span> <span class="identifier">Compare</span> <span class="special">&amp;</span> comp<span class="special">)</span><span class="special">;</span></pre>
331<p><span class="bold"><strong>Effects</strong></span>: Constructs an empty map using the specified comparison object and inserts elements from the ordered range [il.begin(), il.end()). This function is more efficient than the normal range creation for ordered ranges.</p>
332<p><span class="bold"><strong>Requires</strong></span>: [il.begin(), il.end()) must be ordered according to the predicate.</p>
333<p><span class="bold"><strong>Complexity</strong></span>: Linear in N.</p>
334<p><span class="bold"><strong>Note</strong></span>: Non-standard extension. </p>
335</li>
336<li class="listitem">
337<pre class="literallayout"><a name="idm45641213202560-bb"></a><span class="identifier">multimap</span><span class="special">(</span><a class="link" href="ordered_range_t.html" title="Struct ordered_range_t">ordered_range_t</a><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">initializer_list</span><span class="special">&lt;</span> <span class="identifier">value_type</span> <span class="special">&gt;</span> il<span class="special">,</span>
338         <span class="keyword">const</span> <span class="identifier">Compare</span> <span class="special">&amp;</span> comp<span class="special">,</span> <span class="keyword">const</span> <span class="identifier">allocator_type</span> <span class="special">&amp;</span> a<span class="special">)</span><span class="special">;</span></pre>
339<p><span class="bold"><strong>Effects</strong></span>: Constructs an empty map and inserts elements from the ordered range [il.begin(), il.end()). This function is more efficient than the normal range creation for ordered ranges.</p>
340<p><span class="bold"><strong>Requires</strong></span>: [il.begin(), il.end()) must be ordered according to the predicate.</p>
341<p><span class="bold"><strong>Complexity</strong></span>: Linear in N.</p>
342<p><span class="bold"><strong>Note</strong></span>: Non-standard extension. </p>
343</li>
344<li class="listitem">
345<pre class="literallayout"><a name="idm45641213195632-bb"></a><span class="identifier">multimap</span><span class="special">(</span><span class="keyword">const</span> <a class="link" href="multimap.html" title="Class template multimap">multimap</a> <span class="special">&amp;</span> x<span class="special">)</span><span class="special">;</span></pre>
346<p><span class="bold"><strong>Effects</strong></span>: Copy constructs a multimap.</p>
347<p><span class="bold"><strong>Complexity</strong></span>: Linear in x.size(). </p>
348</li>
349<li class="listitem">
350<pre class="literallayout"><a name="idm45641213192368-bb"></a><span class="identifier">multimap</span><span class="special">(</span><a class="link" href="multimap.html" title="Class template multimap">multimap</a> <span class="special">&amp;&amp;</span> x<span class="special">)</span> <span class="keyword">noexcept</span><span class="special">(</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">container</span><span class="special">::</span><span class="identifier">dtl</span><span class="special">::</span><span class="identifier">is_nothrow_move_constructible</span><span class="special">&lt;</span> <span class="identifier">Compare</span> <span class="special">&gt;</span><span class="special">::</span><span class="identifier">value</span><span class="special">)</span><span class="special">)</span><span class="special">;</span></pre>
351<p><span class="bold"><strong>Effects</strong></span>: Move constructs a multimap. Constructs *this using x's resources.</p>
352<p><span class="bold"><strong>Complexity</strong></span>: Constant.</p>
353<p><span class="bold"><strong>Postcondition</strong></span>: x is emptied. </p>
354</li>
355<li class="listitem">
356<pre class="literallayout"><a name="idm45641213188048-bb"></a><span class="identifier">multimap</span><span class="special">(</span><span class="keyword">const</span> <a class="link" href="multimap.html" title="Class template multimap">multimap</a> <span class="special">&amp;</span> x<span class="special">,</span> <span class="keyword">const</span> <span class="identifier">allocator_type</span> <span class="special">&amp;</span> a<span class="special">)</span><span class="special">;</span></pre>
357<p><span class="bold"><strong>Effects</strong></span>: Copy constructs a multimap.</p>
358<p><span class="bold"><strong>Complexity</strong></span>: Linear in x.size(). </p>
359</li>
360<li class="listitem">
361<pre class="literallayout"><a name="idm45641213184096-bb"></a><span class="identifier">multimap</span><span class="special">(</span><a class="link" href="multimap.html" title="Class template multimap">multimap</a> <span class="special">&amp;&amp;</span> x<span class="special">,</span> <span class="keyword">const</span> <span class="identifier">allocator_type</span> <span class="special">&amp;</span> a<span class="special">)</span><span class="special">;</span></pre>
362<p><span class="bold"><strong>Effects</strong></span>: Move constructs a multimap using the specified allocator. Constructs *this using x's resources. <span class="bold"><strong>Complexity</strong></span>: Constant if a == x.get_allocator(), linear otherwise.</p>
363<p><span class="bold"><strong>Postcondition</strong></span>: x is emptied. </p>
364</li>
365<li class="listitem">
366<pre class="literallayout"><a class="link" href="multimap.html" title="Class template multimap">multimap</a> <span class="special">&amp;</span> <a name="idm45641213179488-bb"></a><span class="keyword">operator</span><span class="special">=</span><span class="special">(</span><span class="keyword">const</span> <a class="link" href="multimap.html" title="Class template multimap">multimap</a> <span class="special">&amp;</span> x<span class="special">)</span><span class="special">;</span></pre>
367<p><span class="bold"><strong>Effects</strong></span>: Makes *this a copy of x.</p>
368<p><span class="bold"><strong>Complexity</strong></span>: Linear in x.size(). </p>
369</li>
370<li class="listitem">
371<pre class="literallayout"><a class="link" href="multimap.html" title="Class template multimap">multimap</a> <span class="special">&amp;</span> <a name="idm45641213175648-bb"></a><span class="keyword">operator</span><span class="special">=</span><span class="special">(</span><a class="link" href="multimap.html" title="Class template multimap">multimap</a> <span class="special">&amp;&amp;</span> x<span class="special">)</span> <span class="keyword">noexcept</span><span class="special">(</span><span class="special">(</span><span class="identifier">allocator_traits_type</span><span class="special">::</span><span class="identifier">propagate_on_container_move_assignment</span><span class="special">::</span><span class="identifier">value</span><span class="special">||</span><span class="identifier">allocator_traits_type</span><span class="special">::</span><span class="identifier">is_always_equal</span><span class="special">::</span><span class="identifier">value</span><span class="special">)</span> <span class="special">&amp;&amp;</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">container</span><span class="special">::</span><span class="identifier">dtl</span><span class="special">::</span><span class="identifier">is_nothrow_move_assignable</span><span class="special">&lt;</span> <span class="identifier">Compare</span> <span class="special">&gt;</span><span class="special">::</span><span class="identifier">value</span><span class="special">)</span><span class="special">)</span><span class="special">;</span></pre>
372<p><span class="bold"><strong>Effects</strong></span>: this-&gt;swap(x.get()).</p>
373<p><span class="bold"><strong>Complexity</strong></span>: Constant. </p>
374</li>
375<li class="listitem">
376<pre class="literallayout"><a class="link" href="multimap.html" title="Class template multimap">multimap</a> <span class="special">&amp;</span> <a name="idm45641213171536-bb"></a><span class="keyword">operator</span><span class="special">=</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">initializer_list</span><span class="special">&lt;</span> <span class="identifier">value_type</span> <span class="special">&gt;</span> il<span class="special">)</span><span class="special">;</span></pre>
377<p><span class="bold"><strong>Effects</strong></span>: Assign content of il to *this. </p>
378</li>
379</ol></div>
380</div>
381<div class="refsect2">
382<a name="id-1.3.10.14.14.4.4.7"></a><h3>
383<a name="idm45641213589616-bb"></a><code class="computeroutput">multimap</code> public member functions</h3>
384<div class="orderedlist"><ol class="orderedlist" type="1">
385<li class="listitem"><pre class="literallayout"> <a name="idm45641213589056-bb"></a><span class="identifier">BOOST_STATIC_ASSERT</span><span class="special">(</span><span class="special">(</span><span class="identifier">dtl</span><span class="special">::</span><span class="identifier">is_same</span><span class="special">&lt;</span> <span class="keyword">typename</span> <span class="identifier">allocator_type</span><span class="special">::</span><span class="identifier">value_type</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span> <span class="keyword">const</span> <span class="identifier">Key</span><span class="special">,</span> <span class="identifier">T</span> <span class="special">&gt;</span> <span class="special">&gt;</span><span class="special">::</span><span class="identifier">value</span><span class="special">)</span><span class="special">)</span><span class="special">;</span></pre></li>
386<li class="listitem">
387<pre class="literallayout"><span class="identifier">allocator_type</span> <a name="idm45641213587616-bb"></a><span class="identifier">get_allocator</span><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span></pre>
388<p><span class="bold"><strong>Effects</strong></span>: Returns a copy of the allocator that was passed to the object's constructor.</p>
389<p><span class="bold"><strong>Complexity</strong></span>: Constant. </p>
390</li>
391<li class="listitem">
392<pre class="literallayout"><span class="identifier">stored_allocator_type</span> <span class="special">&amp;</span> <a name="idm45641213584608-bb"></a><span class="identifier">get_stored_allocator</span><span class="special">(</span><span class="special">)</span><span class="special">;</span></pre>
393<p><span class="bold"><strong>Effects</strong></span>: Returns a reference to the internal allocator.</p>
394<p><span class="bold"><strong>Throws</strong></span>: Nothing</p>
395<p><span class="bold"><strong>Complexity</strong></span>: Constant.</p>
396<p><span class="bold"><strong>Note</strong></span>: Non-standard extension. </p>
397</li>
398<li class="listitem">
399<pre class="literallayout"><span class="keyword">const</span> <span class="identifier">stored_allocator_type</span> <span class="special">&amp;</span> <a name="idm45641213580192-bb"></a><span class="identifier">get_stored_allocator</span><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span></pre>
400<p><span class="bold"><strong>Effects</strong></span>: Returns a reference to the internal allocator.</p>
401<p><span class="bold"><strong>Throws</strong></span>: Nothing</p>
402<p><span class="bold"><strong>Complexity</strong></span>: Constant.</p>
403<p><span class="bold"><strong>Note</strong></span>: Non-standard extension. </p>
404</li>
405<li class="listitem">
406<pre class="literallayout"><span class="identifier">iterator</span> <a name="idm45641213575488-bb"></a><span class="identifier">begin</span><span class="special">(</span><span class="special">)</span><span class="special">;</span></pre>
407<p><span class="bold"><strong>Effects</strong></span>: Returns an iterator to the first element contained in the container.</p>
408<p><span class="bold"><strong>Throws</strong></span>: Nothing.</p>
409<p><span class="bold"><strong>Complexity</strong></span>: Constant </p>
410</li>
411<li class="listitem">
412<pre class="literallayout"><span class="identifier">const_iterator</span> <a name="idm45641213571920-bb"></a><span class="identifier">begin</span><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span></pre>
413<p><span class="bold"><strong>Effects</strong></span>: Returns a const_iterator to the first element contained in the container.</p>
414<p><span class="bold"><strong>Throws</strong></span>: Nothing.</p>
415<p><span class="bold"><strong>Complexity</strong></span>: Constant. </p>
416</li>
417<li class="listitem">
418<pre class="literallayout"><span class="identifier">const_iterator</span> <a name="idm45641213568064-bb"></a><span class="identifier">cbegin</span><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span></pre>
419<p><span class="bold"><strong>Effects</strong></span>: Returns a const_iterator to the first element contained in the container.</p>
420<p><span class="bold"><strong>Throws</strong></span>: Nothing.</p>
421<p><span class="bold"><strong>Complexity</strong></span>: Constant. </p>
422</li>
423<li class="listitem">
424<pre class="literallayout"><span class="identifier">iterator</span> <a name="idm45641213564208-bb"></a><span class="identifier">end</span><span class="special">(</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span></pre>
425<p><span class="bold"><strong>Effects</strong></span>: Returns an iterator to the end of the container.</p>
426<p><span class="bold"><strong>Throws</strong></span>: Nothing.</p>
427<p><span class="bold"><strong>Complexity</strong></span>: Constant. </p>
428</li>
429<li class="listitem">
430<pre class="literallayout"><span class="identifier">const_iterator</span> <a name="idm45641213560384-bb"></a><span class="identifier">end</span><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span></pre>
431<p><span class="bold"><strong>Effects</strong></span>: Returns a const_iterator to the end of the container.</p>
432<p><span class="bold"><strong>Throws</strong></span>: Nothing.</p>
433<p><span class="bold"><strong>Complexity</strong></span>: Constant. </p>
434</li>
435<li class="listitem">
436<pre class="literallayout"><span class="identifier">const_iterator</span> <a name="idm45641213556560-bb"></a><span class="identifier">cend</span><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span></pre>
437<p><span class="bold"><strong>Effects</strong></span>: Returns a const_iterator to the end of the container.</p>
438<p><span class="bold"><strong>Throws</strong></span>: Nothing.</p>
439<p><span class="bold"><strong>Complexity</strong></span>: Constant. </p>
440</li>
441<li class="listitem">
442<pre class="literallayout"><span class="identifier">reverse_iterator</span> <a name="idm45641213552736-bb"></a><span class="identifier">rbegin</span><span class="special">(</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span></pre>
443<p><span class="bold"><strong>Effects</strong></span>: Returns a reverse_iterator pointing to the beginning of the reversed container.</p>
444<p><span class="bold"><strong>Throws</strong></span>: Nothing.</p>
445<p><span class="bold"><strong>Complexity</strong></span>: Constant. </p>
446</li>
447<li class="listitem">
448<pre class="literallayout"><span class="identifier">const_reverse_iterator</span> <a name="idm45641213548880-bb"></a><span class="identifier">rbegin</span><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span></pre>
449<p><span class="bold"><strong>Effects</strong></span>: Returns a const_reverse_iterator pointing to the beginning of the reversed container.</p>
450<p><span class="bold"><strong>Throws</strong></span>: Nothing.</p>
451<p><span class="bold"><strong>Complexity</strong></span>: Constant. </p>
452</li>
453<li class="listitem">
454<pre class="literallayout"><span class="identifier">const_reverse_iterator</span> <a name="idm45641213545024-bb"></a><span class="identifier">crbegin</span><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span></pre>
455<p><span class="bold"><strong>Effects</strong></span>: Returns a const_reverse_iterator pointing to the beginning of the reversed container.</p>
456<p><span class="bold"><strong>Throws</strong></span>: Nothing.</p>
457<p><span class="bold"><strong>Complexity</strong></span>: Constant. </p>
458</li>
459<li class="listitem">
460<pre class="literallayout"><span class="identifier">reverse_iterator</span> <a name="idm45641213541168-bb"></a><span class="identifier">rend</span><span class="special">(</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span></pre>
461<p><span class="bold"><strong>Effects</strong></span>: Returns a reverse_iterator pointing to the end of the reversed container.</p>
462<p><span class="bold"><strong>Throws</strong></span>: Nothing.</p>
463<p><span class="bold"><strong>Complexity</strong></span>: Constant. </p>
464</li>
465<li class="listitem">
466<pre class="literallayout"><span class="identifier">const_reverse_iterator</span> <a name="idm45641213537312-bb"></a><span class="identifier">rend</span><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span></pre>
467<p><span class="bold"><strong>Effects</strong></span>: Returns a const_reverse_iterator pointing to the end of the reversed container.</p>
468<p><span class="bold"><strong>Throws</strong></span>: Nothing.</p>
469<p><span class="bold"><strong>Complexity</strong></span>: Constant. </p>
470</li>
471<li class="listitem">
472<pre class="literallayout"><span class="identifier">const_reverse_iterator</span> <a name="idm45641213533456-bb"></a><span class="identifier">crend</span><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span></pre>
473<p><span class="bold"><strong>Effects</strong></span>: Returns a const_reverse_iterator pointing to the end of the reversed container.</p>
474<p><span class="bold"><strong>Throws</strong></span>: Nothing.</p>
475<p><span class="bold"><strong>Complexity</strong></span>: Constant. </p>
476</li>
477<li class="listitem">
478<pre class="literallayout"><span class="keyword">bool</span> <a name="idm45641213529600-bb"></a><span class="identifier">empty</span><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span></pre>
479<p><span class="bold"><strong>Effects</strong></span>: Returns true if the container contains no elements.</p>
480<p><span class="bold"><strong>Throws</strong></span>: Nothing.</p>
481<p><span class="bold"><strong>Complexity</strong></span>: Constant. </p>
482</li>
483<li class="listitem">
484<pre class="literallayout"><span class="identifier">size_type</span> <a name="idm45641213525776-bb"></a><span class="identifier">size</span><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span></pre>
485<p><span class="bold"><strong>Effects</strong></span>: Returns the number of the elements contained in the container.</p>
486<p><span class="bold"><strong>Throws</strong></span>: Nothing.</p>
487<p><span class="bold"><strong>Complexity</strong></span>: Constant. </p>
488</li>
489<li class="listitem">
490<pre class="literallayout"><span class="identifier">size_type</span> <a name="idm45641213521936-bb"></a><span class="identifier">max_size</span><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span></pre>
491<p><span class="bold"><strong>Effects</strong></span>: Returns the largest possible size of the container.</p>
492<p><span class="bold"><strong>Throws</strong></span>: Nothing.</p>
493<p><span class="bold"><strong>Complexity</strong></span>: Constant. </p>
494</li>
495<li class="listitem">
496<pre class="literallayout"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span><span class="special">...</span> Args<span class="special">&gt;</span> <span class="identifier">iterator</span> <a name="idm45641213518112-bb"></a><span class="identifier">emplace</span><span class="special">(</span><span class="identifier">Args</span> <span class="special">&amp;&amp;</span><span class="special">...</span> args<span class="special">)</span><span class="special">;</span></pre>
497<p><span class="bold"><strong>Effects</strong></span>: Inserts an object of type T constructed with std::forward&lt;Args&gt;(args)... in the container. p is a hint pointing to where the insert should start to search.</p>
498<p><span class="bold"><strong>Returns</strong></span>: An iterator pointing to the element with key equivalent to the key of x.</p>
499<p><span class="bold"><strong>Complexity</strong></span>: Logarithmic in general, but amortized constant if t is inserted right before p. </p>
500</li>
501<li class="listitem">
502<pre class="literallayout"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span><span class="special">...</span> Args<span class="special">&gt;</span>
503  <span class="identifier">iterator</span> <a name="idm45641213512496-bb"></a><span class="identifier">emplace_hint</span><span class="special">(</span><span class="identifier">const_iterator</span> p<span class="special">,</span> <span class="identifier">Args</span> <span class="special">&amp;&amp;</span><span class="special">...</span> args<span class="special">)</span><span class="special">;</span></pre>
504<p><span class="bold"><strong>Effects</strong></span>: Inserts an object of type T constructed with std::forward&lt;Args&gt;(args)... in the container. p is a hint pointing to where the insert should start to search.</p>
505<p><span class="bold"><strong>Returns</strong></span>: An iterator pointing to the element with key equivalent to the key of x.</p>
506<p><span class="bold"><strong>Complexity</strong></span>: Logarithmic in general, but amortized constant if t is inserted right before p. </p>
507</li>
508<li class="listitem">
509<pre class="literallayout"><span class="identifier">iterator</span> <a name="idm45641213506192-bb"></a><span class="identifier">insert</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">value_type</span> <span class="special">&amp;</span> x<span class="special">)</span><span class="special">;</span></pre>
510<p><span class="bold"><strong>Effects</strong></span>: Inserts x and returns the iterator pointing to the newly inserted element.</p>
511<p><span class="bold"><strong>Complexity</strong></span>: Logarithmic. </p>
512</li>
513<li class="listitem">
514<pre class="literallayout"><span class="identifier">iterator</span> <a name="idm45641213502768-bb"></a><span class="identifier">insert</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">nonconst_value_type</span> <span class="special">&amp;</span> x<span class="special">)</span><span class="special">;</span></pre>
515<p><span class="bold"><strong>Effects</strong></span>: Inserts a new value constructed from x and returns the iterator pointing to the newly inserted element.</p>
516<p><span class="bold"><strong>Complexity</strong></span>: Logarithmic. </p>
517</li>
518<li class="listitem">
519<pre class="literallayout"><span class="identifier">iterator</span> <a name="idm45641213499296-bb"></a><span class="identifier">insert</span><span class="special">(</span><span class="identifier">nonconst_value_type</span> <span class="special">&amp;&amp;</span> x<span class="special">)</span><span class="special">;</span></pre>
520<p><span class="bold"><strong>Effects</strong></span>: Inserts a new value move-constructed from x and returns the iterator pointing to the newly inserted element.</p>
521<p><span class="bold"><strong>Complexity</strong></span>: Logarithmic. </p>
522</li>
523<li class="listitem">
524<pre class="literallayout"><span class="identifier">iterator</span> <a name="idm45641213495840-bb"></a><span class="identifier">insert</span><span class="special">(</span><span class="identifier">movable_value_type</span> <span class="special">&amp;&amp;</span> x<span class="special">)</span><span class="special">;</span></pre>
525<p><span class="bold"><strong>Effects</strong></span>: Inserts a new value move-constructed from x and returns the iterator pointing to the newly inserted element.</p>
526<p><span class="bold"><strong>Complexity</strong></span>: Logarithmic. </p>
527</li>
528<li class="listitem">
529<pre class="literallayout"><span class="identifier">iterator</span> <a name="idm45641213492384-bb"></a><span class="identifier">insert</span><span class="special">(</span><span class="identifier">const_iterator</span> p<span class="special">,</span> <span class="keyword">const</span> <span class="identifier">value_type</span> <span class="special">&amp;</span> x<span class="special">)</span><span class="special">;</span></pre>
530<p><span class="bold"><strong>Effects</strong></span>: Inserts a copy of x in the container. p is a hint pointing to where the insert should start to search.</p>
531<p><span class="bold"><strong>Returns</strong></span>: An iterator pointing to the element with key equivalent to the key of x.</p>
532<p><span class="bold"><strong>Complexity</strong></span>: Logarithmic in general, but amortized constant if t is inserted right before p. </p>
533</li>
534<li class="listitem">
535<pre class="literallayout"><span class="identifier">iterator</span> <a name="idm45641213487264-bb"></a><span class="identifier">insert</span><span class="special">(</span><span class="identifier">const_iterator</span> p<span class="special">,</span> <span class="keyword">const</span> <span class="identifier">nonconst_value_type</span> <span class="special">&amp;</span> x<span class="special">)</span><span class="special">;</span></pre>
536<p><span class="bold"><strong>Effects</strong></span>: Inserts a new value constructed from x in the container. p is a hint pointing to where the insert should start to search.</p>
537<p><span class="bold"><strong>Returns</strong></span>: An iterator pointing to the element with key equivalent to the key of x.</p>
538<p><span class="bold"><strong>Complexity</strong></span>: Logarithmic in general, but amortized constant if t is inserted right before p. </p>
539</li>
540<li class="listitem">
541<pre class="literallayout"><span class="identifier">iterator</span> <a name="idm45641213482112-bb"></a><span class="identifier">insert</span><span class="special">(</span><span class="identifier">const_iterator</span> p<span class="special">,</span> <span class="identifier">nonconst_value_type</span> <span class="special">&amp;&amp;</span> x<span class="special">)</span><span class="special">;</span></pre>
542<p><span class="bold"><strong>Effects</strong></span>: Inserts a new value move constructed from x in the container. p is a hint pointing to where the insert should start to search.</p>
543<p><span class="bold"><strong>Returns</strong></span>: An iterator pointing to the element with key equivalent to the key of x.</p>
544<p><span class="bold"><strong>Complexity</strong></span>: Logarithmic in general, but amortized constant if t is inserted right before p. </p>
545</li>
546<li class="listitem">
547<pre class="literallayout"><span class="identifier">iterator</span> <a name="idm45641213476976-bb"></a><span class="identifier">insert</span><span class="special">(</span><span class="identifier">const_iterator</span> p<span class="special">,</span> <span class="identifier">movable_value_type</span> <span class="special">&amp;&amp;</span> x<span class="special">)</span><span class="special">;</span></pre>
548<p><span class="bold"><strong>Effects</strong></span>: Inserts a new value move constructed from x in the container. p is a hint pointing to where the insert should start to search.</p>
549<p><span class="bold"><strong>Returns</strong></span>: An iterator pointing to the element with key equivalent to the key of x.</p>
550<p><span class="bold"><strong>Complexity</strong></span>: Logarithmic in general, but amortized constant if t is inserted right before p. </p>
551</li>
552<li class="listitem">
553<pre class="literallayout"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> InputIterator<span class="special">&gt;</span>
554  <span class="keyword">void</span> <a name="idm45641213471840-bb"></a><span class="identifier">insert</span><span class="special">(</span><span class="identifier">InputIterator</span> first<span class="special">,</span> <span class="identifier">InputIterator</span> last<span class="special">)</span><span class="special">;</span></pre>
555<p><span class="bold"><strong>Requires</strong></span>: first, last are not iterators into *this.</p>
556<p><span class="bold"><strong>Effects</strong></span>: inserts each element from the range [first,last) .</p>
557<p><span class="bold"><strong>Complexity</strong></span>: At most N log(size()+N) (N is the distance from first to last) </p>
558</li>
559<li class="listitem">
560<pre class="literallayout"><span class="keyword">void</span> <a name="idm45641213465984-bb"></a><span class="identifier">insert</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">initializer_list</span><span class="special">&lt;</span> <span class="identifier">value_type</span> <span class="special">&gt;</span> il<span class="special">)</span><span class="special">;</span></pre>
561<p><span class="bold"><strong>Effects</strong></span>: inserts each element from the range [il.begin(), il.end().</p>
562<p><span class="bold"><strong>Complexity</strong></span>: At most N log(size()+N) (N is the distance from il.begin() to il.end()) </p>
563</li>
564<li class="listitem">
565<pre class="literallayout"><span class="identifier">iterator</span> <a name="idm45641213462496-bb"></a><span class="identifier">insert</span><span class="special">(</span><span class="identifier">node_type</span> <span class="special">&amp;&amp;</span> nh<span class="special">)</span><span class="special">;</span></pre>
566<p><span class="bold"><strong>Requires</strong></span>: nh is empty or this-&gt;get_allocator() == nh.get_allocator().</p>
567<p><span class="bold"><strong>Effects/Returns</strong></span>: If nh is empty, has no effect and returns end(). Otherwise, inserts the element owned by nh and returns an iterator pointing to the newly inserted element. If a range containing elements with keys equivalent to nh.key() exists, the element is inserted at the end of that range. nh is always emptied.</p>
568<p><span class="bold"><strong>Complexity</strong></span>: Logarithmic </p>
569</li>
570<li class="listitem">
571<pre class="literallayout"><span class="identifier">iterator</span> <a name="idm45641213457952-bb"></a><span class="identifier">insert</span><span class="special">(</span><span class="identifier">const_iterator</span> hint<span class="special">,</span> <span class="identifier">node_type</span> <span class="special">&amp;&amp;</span> nh<span class="special">)</span><span class="special">;</span></pre>
572<p><span class="bold"><strong>Effects</strong></span>: Same as <code class="computeroutput">insert(node_type &amp;&amp; nh)</code> but the element is inserted as close as possible to the position just prior to "hint".</p>
573<p><span class="bold"><strong>Complexity</strong></span>: logarithmic in general, but amortized constant if the element is inserted right before "hint". </p>
574</li>
575<li class="listitem">
576<pre class="literallayout"><span class="identifier">iterator</span> <a name="idm45641213453312-bb"></a><span class="identifier">erase</span><span class="special">(</span><span class="identifier">const_iterator</span> p<span class="special">)</span><span class="special">;</span></pre>
577<p><span class="bold"><strong>Effects</strong></span>: Erases the element pointed to by p.</p>
578<p><span class="bold"><strong>Returns</strong></span>: Returns an iterator pointing to the element immediately following q prior to the element being erased. If no such element exists, returns end().</p>
579<p><span class="bold"><strong>Complexity</strong></span>: Amortized constant time </p>
580</li>
581<li class="listitem">
582<pre class="literallayout"><span class="identifier">size_type</span> <a name="idm45641213448944-bb"></a><span class="identifier">erase</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">key_type</span> <span class="special">&amp;</span> x<span class="special">)</span><span class="special">;</span></pre>
583<p><span class="bold"><strong>Effects</strong></span>: Erases all elements in the container with key equivalent to x.</p>
584<p><span class="bold"><strong>Returns</strong></span>: Returns the number of erased elements.</p>
585<p><span class="bold"><strong>Complexity</strong></span>: log(size()) + count(k) </p>
586</li>
587<li class="listitem">
588<pre class="literallayout"><span class="identifier">iterator</span> <a name="idm45641213444640-bb"></a><span class="identifier">erase</span><span class="special">(</span><span class="identifier">const_iterator</span> first<span class="special">,</span> <span class="identifier">const_iterator</span> last<span class="special">)</span><span class="special">;</span></pre>
589<p><span class="bold"><strong>Effects</strong></span>: Erases all the elements in the range [first, last).</p>
590<p><span class="bold"><strong>Returns</strong></span>: Returns last.</p>
591<p><span class="bold"><strong>Complexity</strong></span>: log(size())+N where N is the distance from first to last. </p>
592</li>
593<li class="listitem">
594<pre class="literallayout"><span class="identifier">node_type</span> <a name="idm45641213439664-bb"></a><span class="identifier">extract</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">key_type</span> <span class="special">&amp;</span> k<span class="special">)</span><span class="special">;</span></pre>
595<p><span class="bold"><strong>Effects</strong></span>: Removes the first element in the container with key equivalent to k.</p>
596<p><span class="bold"><strong>Returns</strong></span>: A node_type owning the element if found, otherwise an empty node_type.</p>
597<p><span class="bold"><strong>Complexity</strong></span>: log(size()). </p>
598</li>
599<li class="listitem">
600<pre class="literallayout"><span class="identifier">node_type</span> <a name="idm45641213435344-bb"></a><span class="identifier">extract</span><span class="special">(</span><span class="identifier">const_iterator</span> position<span class="special">)</span><span class="special">;</span></pre>
601<p><span class="bold"><strong>Effects</strong></span>: Removes the element pointed to by "position".</p>
602<p><span class="bold"><strong>Returns</strong></span>: A node_type owning the element, otherwise an empty node_type.</p>
603<p><span class="bold"><strong>Complexity</strong></span>: Amortized constant. </p>
604</li>
605<li class="listitem">
606<pre class="literallayout"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> C2<span class="special">&gt;</span>
607  <span class="keyword">void</span> <a name="idm45641213431056-bb"></a><span class="identifier">merge</span><span class="special">(</span><a class="link" href="multimap.html" title="Class template multimap">multimap</a><span class="special">&lt;</span> <span class="identifier">Key</span><span class="special">,</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">C2</span><span class="special">,</span> <span class="identifier">Allocator</span><span class="special">,</span> <span class="identifier">Options</span> <span class="special">&gt;</span> <span class="special">&amp;</span> source<span class="special">)</span><span class="special">;</span></pre>
608<p><span class="bold"><strong>Requires</strong></span>: this-&gt;get_allocator() == source.get_allocator().</p>
609<p><span class="bold"><strong>Effects</strong></span>: Extracts each element in source and insert it into a using the comparison object of *this.</p>
610<p><span class="bold"><strong>Postcondition</strong></span>: Pointers and references to the transferred elements of source refer to those same elements but as members of *this. Iterators referring to the transferred elements will continue to refer to their elements, but they now behave as iterators into *this, not into source.</p>
611<p><span class="bold"><strong>Throws</strong></span>: Nothing unless the comparison object throws.</p>
612<p><span class="bold"><strong>Complexity</strong></span>: N log(size() + N) (N has the value source.size()) </p>
613</li>
614<li class="listitem">
615<pre class="literallayout"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> C2<span class="special">&gt;</span>
616  <span class="keyword">void</span> <a name="idm45641213423568-bb"></a><span class="identifier">merge</span><span class="special">(</span><a class="link" href="multimap.html" title="Class template multimap">multimap</a><span class="special">&lt;</span> <span class="identifier">Key</span><span class="special">,</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">C2</span><span class="special">,</span> <span class="identifier">Allocator</span><span class="special">,</span> <span class="identifier">Options</span> <span class="special">&gt;</span> <span class="special">&amp;&amp;</span> source<span class="special">)</span><span class="special">;</span></pre>
617<p><span class="bold"><strong>Requires</strong></span>: this-&gt;get_allocator() == source.get_allocator().</p>
618<p><span class="bold"><strong>Effects</strong></span>: Extracts each element in source and insert it into a using the comparison object of *this.</p>
619<p><span class="bold"><strong>Postcondition</strong></span>: Pointers and references to the transferred elements of source refer to those same elements but as members of *this. Iterators referring to the transferred elements will continue to refer to their elements, but they now behave as iterators into *this, not into source.</p>
620<p><span class="bold"><strong>Throws</strong></span>: Nothing unless the comparison object throws.</p>
621<p><span class="bold"><strong>Complexity</strong></span>: N log(size() + N) (N has the value source.size()) </p>
622</li>
623<li class="listitem">
624<pre class="literallayout"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> C2<span class="special">&gt;</span>
625  <span class="keyword">void</span> <a name="idm45641213416080-bb"></a><span class="identifier">merge</span><span class="special">(</span><a class="link" href="map.html" title="Class template map">map</a><span class="special">&lt;</span> <span class="identifier">Key</span><span class="special">,</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">C2</span><span class="special">,</span> <span class="identifier">Allocator</span><span class="special">,</span> <span class="identifier">Options</span> <span class="special">&gt;</span> <span class="special">&amp;</span> source<span class="special">)</span><span class="special">;</span></pre>
626<p><span class="bold"><strong>Requires</strong></span>: this-&gt;get_allocator() == source.get_allocator().</p>
627<p><span class="bold"><strong>Effects</strong></span>: Extracts each element in source and insert it into a using the comparison object of *this.</p>
628<p><span class="bold"><strong>Postcondition</strong></span>: Pointers and references to the transferred elements of source refer to those same elements but as members of *this. Iterators referring to the transferred elements will continue to refer to their elements, but they now behave as iterators into *this, not into source.</p>
629<p><span class="bold"><strong>Throws</strong></span>: Nothing unless the comparison object throws.</p>
630<p><span class="bold"><strong>Complexity</strong></span>: N log(size() + N) (N has the value source.size()) </p>
631</li>
632<li class="listitem">
633<pre class="literallayout"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> C2<span class="special">&gt;</span>
634  <span class="keyword">void</span> <a name="idm45641213408592-bb"></a><span class="identifier">merge</span><span class="special">(</span><a class="link" href="map.html" title="Class template map">map</a><span class="special">&lt;</span> <span class="identifier">Key</span><span class="special">,</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">C2</span><span class="special">,</span> <span class="identifier">Allocator</span><span class="special">,</span> <span class="identifier">Options</span> <span class="special">&gt;</span> <span class="special">&amp;&amp;</span> source<span class="special">)</span><span class="special">;</span></pre>
635<p><span class="bold"><strong>Requires</strong></span>: this-&gt;get_allocator() == source.get_allocator().</p>
636<p><span class="bold"><strong>Effects</strong></span>: Extracts each element in source and insert it into a using the comparison object of *this.</p>
637<p><span class="bold"><strong>Postcondition</strong></span>: Pointers and references to the transferred elements of source refer to those same elements but as members of *this. Iterators referring to the transferred elements will continue to refer to their elements, but they now behave as iterators into *this, not into source.</p>
638<p><span class="bold"><strong>Throws</strong></span>: Nothing unless the comparison object throws.</p>
639<p><span class="bold"><strong>Complexity</strong></span>: N log(size() + N) (N has the value source.size()) </p>
640</li>
641<li class="listitem">
642<pre class="literallayout"><span class="keyword">void</span> <a name="idm45641213401104-bb"></a><span class="identifier">swap</span><span class="special">(</span><a class="link" href="multiset.html" title="Class template multiset">multiset</a> <span class="special">&amp;</span> x<span class="special">)</span> <span class="keyword">noexcept</span><span class="special">(</span><span class="identifier">allocator_traits_type</span><span class="special">::</span><span class="identifier">is_always_equal</span><span class="special">::</span><span class="identifier">value</span> <span class="special">&amp;&amp;</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">container</span><span class="special">::</span><span class="identifier">dtl</span><span class="special">::</span><span class="identifier">is_nothrow_swappable</span><span class="special">&lt;</span> <span class="identifier">Compare</span> <span class="special">&gt;</span><span class="special">::</span><span class="identifier">value</span><span class="special">)</span><span class="special">)</span><span class="special">;</span></pre>
643<p><span class="bold"><strong>Effects</strong></span>: Swaps the contents of *this and x.</p>
644<p><span class="bold"><strong>Throws</strong></span>: Nothing.</p>
645<p><span class="bold"><strong>Complexity</strong></span>: Constant. </p>
646</li>
647<li class="listitem">
648<pre class="literallayout"><span class="keyword">void</span> <a name="idm45641213396208-bb"></a><span class="identifier">clear</span><span class="special">(</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span></pre>
649<p><span class="bold"><strong>Effects</strong></span>: erase(begin(),end()).</p>
650<p><span class="bold"><strong>Postcondition</strong></span>: size() == 0.</p>
651<p><span class="bold"><strong>Complexity</strong></span>: linear in size(). </p>
652</li>
653<li class="listitem">
654<pre class="literallayout"><span class="identifier">key_compare</span> <a name="idm45641213392416-bb"></a><span class="identifier">key_comp</span><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span></pre>
655<p><span class="bold"><strong>Effects</strong></span>: Returns the comparison object out of which a was constructed.</p>
656<p><span class="bold"><strong>Complexity</strong></span>: Constant. </p>
657</li>
658<li class="listitem">
659<pre class="literallayout"><span class="identifier">value_compare</span> <a name="idm45641213389424-bb"></a><span class="identifier">value_comp</span><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span></pre>
660<p><span class="bold"><strong>Effects</strong></span>: Returns an object of value_compare constructed out of the comparison object.</p>
661<p><span class="bold"><strong>Complexity</strong></span>: Constant. </p>
662</li>
663<li class="listitem">
664<pre class="literallayout"><span class="identifier">iterator</span> <a name="idm45641213386416-bb"></a><span class="identifier">find</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">key_type</span> <span class="special">&amp;</span> x<span class="special">)</span><span class="special">;</span></pre>
665<p><span class="bold"><strong>Returns</strong></span>: An iterator pointing to an element with the key equivalent to x, or end() if such an element is not found.</p>
666<p><span class="bold"><strong>Complexity</strong></span>: Logarithmic. </p>
667</li>
668<li class="listitem">
669<pre class="literallayout"><span class="identifier">const_iterator</span> <a name="idm45641213382960-bb"></a><span class="identifier">find</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">key_type</span> <span class="special">&amp;</span> x<span class="special">)</span> <span class="keyword">const</span><span class="special">;</span></pre>
670<p><span class="bold"><strong>Returns</strong></span>: A const iterator pointing to an element with the key equivalent to x, or end() if such an element is not found.</p>
671<p><span class="bold"><strong>Complexity</strong></span>: Logarithmic. </p>
672</li>
673<li class="listitem">
674<pre class="literallayout"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> K<span class="special">&gt;</span> <span class="identifier">iterator</span> <a name="idm45641213379232-bb"></a><span class="identifier">find</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">K</span> <span class="special">&amp;</span> x<span class="special">)</span><span class="special">;</span></pre>
675<p><span class="bold"><strong>Requires</strong></span>: This overload is available only if key_compare::is_transparent exists.</p>
676<p><span class="bold"><strong>Returns</strong></span>: An iterator pointing to an element with the key equivalent to x, or end() if such an element is not found.</p>
677<p><span class="bold"><strong>Complexity</strong></span>: Logarithmic. </p>
678</li>
679<li class="listitem">
680<pre class="literallayout"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> K<span class="special">&gt;</span> <span class="identifier">const_iterator</span> <a name="idm45641213374016-bb"></a><span class="identifier">find</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">K</span> <span class="special">&amp;</span> x<span class="special">)</span> <span class="keyword">const</span><span class="special">;</span></pre>
681<p><span class="bold"><strong>Requires</strong></span>: This overload is available only if key_compare::is_transparent exists.</p>
682<p><span class="bold"><strong>Returns</strong></span>: A const_iterator pointing to an element with the key equivalent to x, or end() if such an element is not found.</p>
683<p><span class="bold"><strong>Complexity</strong></span>: Logarithmic. </p>
684</li>
685<li class="listitem">
686<pre class="literallayout"><span class="identifier">size_type</span> <a name="idm45641213368528-bb"></a><span class="identifier">count</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">key_type</span> <span class="special">&amp;</span> x<span class="special">)</span> <span class="keyword">const</span><span class="special">;</span></pre>
687<p><span class="bold"><strong>Returns</strong></span>: The number of elements with key equivalent to x.</p>
688<p><span class="bold"><strong>Complexity</strong></span>: log(size())+count(k) </p>
689</li>
690<li class="listitem">
691<pre class="literallayout"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> K<span class="special">&gt;</span> <span class="identifier">size_type</span> <a name="idm45641213364864-bb"></a><span class="identifier">count</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">K</span> <span class="special">&amp;</span> x<span class="special">)</span> <span class="keyword">const</span><span class="special">;</span></pre>
692<p><span class="bold"><strong>Requires</strong></span>: This overload is available only if key_compare::is_transparent exists.</p>
693<p><span class="bold"><strong>Returns</strong></span>: The number of elements with key equivalent to x.</p>
694<p><span class="bold"><strong>Complexity</strong></span>: log(size())+count(k) </p>
695</li>
696<li class="listitem">
697<pre class="literallayout"><span class="keyword">bool</span> <a name="idm45641213359440-bb"></a><span class="identifier">contains</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">key_type</span> <span class="special">&amp;</span> x<span class="special">)</span> <span class="keyword">const</span><span class="special">;</span></pre>
698<p><span class="bold"><strong>Returns</strong></span>: Returns true if there is an element with key equivalent to key in the container, otherwise false.</p>
699<p><span class="bold"><strong>Complexity</strong></span>: log(size()). </p>
700</li>
701<li class="listitem">
702<pre class="literallayout"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> K<span class="special">&gt;</span> <span class="keyword">bool</span> <a name="idm45641213355728-bb"></a><span class="identifier">contains</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">K</span> <span class="special">&amp;</span> x<span class="special">)</span> <span class="keyword">const</span><span class="special">;</span></pre>
703<p><span class="bold"><strong>Requires</strong></span>: This overload is available only if key_compare::is_transparent exists.</p>
704<p><span class="bold"><strong>Returns</strong></span>: Returns true if there is an element with key equivalent to key in the container, otherwise false.</p>
705<p><span class="bold"><strong>Complexity</strong></span>: log(size()). </p>
706</li>
707<li class="listitem">
708<pre class="literallayout"><span class="identifier">iterator</span> <a name="idm45641213350256-bb"></a><span class="identifier">lower_bound</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">key_type</span> <span class="special">&amp;</span> x<span class="special">)</span><span class="special">;</span></pre>
709<p><span class="bold"><strong>Returns</strong></span>: An iterator pointing to the first element with key not less than x, or end() if such an element is not found.</p>
710<p><span class="bold"><strong>Complexity</strong></span>: Logarithmic </p>
711</li>
712<li class="listitem">
713<pre class="literallayout"><span class="identifier">const_iterator</span> <a name="idm45641213346800-bb"></a><span class="identifier">lower_bound</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">key_type</span> <span class="special">&amp;</span> x<span class="special">)</span> <span class="keyword">const</span><span class="special">;</span></pre>
714<p><span class="bold"><strong>Returns</strong></span>: A const iterator pointing to the first element with key not less than x, or end() if such an element is not found.</p>
715<p><span class="bold"><strong>Complexity</strong></span>: Logarithmic </p>
716</li>
717<li class="listitem">
718<pre class="literallayout"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> K<span class="special">&gt;</span> <span class="identifier">iterator</span> <a name="idm45641213343072-bb"></a><span class="identifier">lower_bound</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">K</span> <span class="special">&amp;</span> x<span class="special">)</span><span class="special">;</span></pre>
719<p><span class="bold"><strong>Requires</strong></span>: This overload is available only if key_compare::is_transparent exists.</p>
720<p><span class="bold"><strong>Returns</strong></span>: An iterator pointing to the first element with key not less than x, or end() if such an element is not found.</p>
721<p><span class="bold"><strong>Complexity</strong></span>: Logarithmic </p>
722</li>
723<li class="listitem">
724<pre class="literallayout"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> K<span class="special">&gt;</span> <span class="identifier">const_iterator</span> <a name="idm45641213337856-bb"></a><span class="identifier">lower_bound</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">K</span> <span class="special">&amp;</span> x<span class="special">)</span> <span class="keyword">const</span><span class="special">;</span></pre>
725<p><span class="bold"><strong>Requires</strong></span>: This overload is available only if key_compare::is_transparent exists.</p>
726<p><span class="bold"><strong>Returns</strong></span>: A const iterator pointing to the first element with key not less than x, or end() if such an element is not found.</p>
727<p><span class="bold"><strong>Complexity</strong></span>: Logarithmic </p>
728</li>
729<li class="listitem">
730<pre class="literallayout"><span class="identifier">iterator</span> <a name="idm45641213332368-bb"></a><span class="identifier">upper_bound</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">key_type</span> <span class="special">&amp;</span> x<span class="special">)</span><span class="special">;</span></pre>
731<p><span class="bold"><strong>Returns</strong></span>: An iterator pointing to the first element with key greater than x, or end() if such an element is not found.</p>
732<p><span class="bold"><strong>Complexity</strong></span>: Logarithmic </p>
733</li>
734<li class="listitem">
735<pre class="literallayout"><span class="identifier">const_iterator</span> <a name="idm45641213328912-bb"></a><span class="identifier">upper_bound</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">key_type</span> <span class="special">&amp;</span> x<span class="special">)</span> <span class="keyword">const</span><span class="special">;</span></pre>
736<p><span class="bold"><strong>Returns</strong></span>: A const iterator pointing to the first element with key greater than x, or end() if such an element is not found.</p>
737<p><span class="bold"><strong>Complexity</strong></span>: Logarithmic </p>
738</li>
739<li class="listitem">
740<pre class="literallayout"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> K<span class="special">&gt;</span> <span class="identifier">iterator</span> <a name="idm45641213325184-bb"></a><span class="identifier">upper_bound</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">K</span> <span class="special">&amp;</span> x<span class="special">)</span><span class="special">;</span></pre>
741<p><span class="bold"><strong>Requires</strong></span>: This overload is available only if key_compare::is_transparent exists.</p>
742<p><span class="bold"><strong>Returns</strong></span>: An iterator pointing to the first element with key greater than x, or end() if such an element is not found.</p>
743<p><span class="bold"><strong>Complexity</strong></span>: Logarithmic </p>
744</li>
745<li class="listitem">
746<pre class="literallayout"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> K<span class="special">&gt;</span> <span class="identifier">const_iterator</span> <a name="idm45641213319968-bb"></a><span class="identifier">upper_bound</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">K</span> <span class="special">&amp;</span> x<span class="special">)</span> <span class="keyword">const</span><span class="special">;</span></pre>
747<p><span class="bold"><strong>Requires</strong></span>: This overload is available only if key_compare::is_transparent exists.</p>
748<p><span class="bold"><strong>Returns</strong></span>: A const iterator pointing to the first element with key greater than x, or end() if such an element is not found.</p>
749<p><span class="bold"><strong>Complexity</strong></span>: Logarithmic </p>
750</li>
751<li class="listitem">
752<pre class="literallayout"><span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span> <span class="identifier">iterator</span><span class="special">,</span> <span class="identifier">iterator</span> <span class="special">&gt;</span> <a name="idm45641213314480-bb"></a><span class="identifier">equal_range</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">key_type</span> <span class="special">&amp;</span> x<span class="special">)</span><span class="special">;</span></pre>
753<p><span class="bold"><strong>Effects</strong></span>: Equivalent to std::make_pair(this-&gt;lower_bound(k), this-&gt;upper_bound(k)).</p>
754<p><span class="bold"><strong>Complexity</strong></span>: Logarithmic </p>
755</li>
756<li class="listitem">
757<pre class="literallayout"><span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span> <span class="identifier">const_iterator</span><span class="special">,</span> <span class="identifier">const_iterator</span> <span class="special">&gt;</span>
758<a name="idm45641213311040-bb"></a><span class="identifier">equal_range</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">key_type</span> <span class="special">&amp;</span> x<span class="special">)</span> <span class="keyword">const</span><span class="special">;</span></pre>
759<p><span class="bold"><strong>Effects</strong></span>: Equivalent to std::make_pair(this-&gt;lower_bound(k), this-&gt;upper_bound(k)).</p>
760<p><span class="bold"><strong>Complexity</strong></span>: Logarithmic </p>
761</li>
762<li class="listitem">
763<pre class="literallayout"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> K<span class="special">&gt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span> <span class="identifier">iterator</span><span class="special">,</span> <span class="identifier">iterator</span> <span class="special">&gt;</span> <a name="idm45641213307312-bb"></a><span class="identifier">equal_range</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">K</span> <span class="special">&amp;</span> x<span class="special">)</span><span class="special">;</span></pre>
764<p><span class="bold"><strong>Requires</strong></span>: This overload is available only if key_compare::is_transparent exists.</p>
765<p><span class="bold"><strong>Effects</strong></span>: Equivalent to std::make_pair(this-&gt;lower_bound(k), this-&gt;upper_bound(k)).</p>
766<p><span class="bold"><strong>Complexity</strong></span>: Logarithmic </p>
767</li>
768<li class="listitem">
769<pre class="literallayout"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> K<span class="special">&gt;</span>
770  <span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span> <span class="identifier">const_iterator</span><span class="special">,</span> <span class="identifier">const_iterator</span> <span class="special">&gt;</span> <a name="idm45641213302112-bb"></a><span class="identifier">equal_range</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">K</span> <span class="special">&amp;</span> x<span class="special">)</span> <span class="keyword">const</span><span class="special">;</span></pre>
771<p><span class="bold"><strong>Requires</strong></span>: This overload is available only if key_compare::is_transparent exists.</p>
772<p><span class="bold"><strong>Effects</strong></span>: Equivalent to std::make_pair(this-&gt;lower_bound(k), this-&gt;upper_bound(k)).</p>
773<p><span class="bold"><strong>Complexity</strong></span>: Logarithmic </p>
774</li>
775<li class="listitem">
776<pre class="literallayout"><span class="keyword">void</span> <a name="idm45641213296624-bb"></a><span class="identifier">rebalance</span><span class="special">(</span><span class="special">)</span><span class="special">;</span></pre>
777<p><span class="bold"><strong>Effects</strong></span>: Rebalances the tree. It's a no-op for Red-Black and AVL trees.</p>
778<p><span class="bold"><strong>Complexity</strong></span>: Linear </p>
779</li>
780</ol></div>
781</div>
782<div class="refsect2">
783<a name="id-1.3.10.14.14.4.4.8"></a><h3>
784<a name="idm45641213168976-bb"></a><code class="computeroutput">multimap</code> friend functions</h3>
785<div class="orderedlist"><ol class="orderedlist" type="1">
786<li class="listitem">
787<pre class="literallayout"><span class="keyword">friend</span> <span class="keyword">bool</span> <a name="idm45641213168416-bb"></a><span class="keyword">operator</span><span class="special">==</span><span class="special">(</span><span class="keyword">const</span> <a class="link" href="multimap.html" title="Class template multimap">multimap</a> <span class="special">&amp;</span> x<span class="special">,</span> <span class="keyword">const</span> <a class="link" href="multimap.html" title="Class template multimap">multimap</a> <span class="special">&amp;</span> y<span class="special">)</span><span class="special">;</span></pre>
788<p><span class="bold"><strong>Effects</strong></span>: Returns true if x and y are equal</p>
789<p><span class="bold"><strong>Complexity</strong></span>: Linear to the number of elements in the container. </p>
790</li>
791<li class="listitem">
792<pre class="literallayout"><span class="keyword">friend</span> <span class="keyword">bool</span> <a name="idm45641213163424-bb"></a><span class="keyword">operator</span><span class="special">!=</span><span class="special">(</span><span class="keyword">const</span> <a class="link" href="multimap.html" title="Class template multimap">multimap</a> <span class="special">&amp;</span> x<span class="special">,</span> <span class="keyword">const</span> <a class="link" href="multimap.html" title="Class template multimap">multimap</a> <span class="special">&amp;</span> y<span class="special">)</span><span class="special">;</span></pre>
793<p><span class="bold"><strong>Effects</strong></span>: Returns true if x and y are unequal</p>
794<p><span class="bold"><strong>Complexity</strong></span>: Linear to the number of elements in the container. </p>
795</li>
796<li class="listitem">
797<pre class="literallayout"><span class="keyword">friend</span> <span class="keyword">bool</span> <a name="idm45641213158432-bb"></a><span class="keyword">operator</span><span class="special">&lt;</span><span class="special">(</span><span class="keyword">const</span> <a class="link" href="multimap.html" title="Class template multimap">multimap</a> <span class="special">&amp;</span> x<span class="special">,</span> <span class="keyword">const</span> <a class="link" href="multimap.html" title="Class template multimap">multimap</a> <span class="special">&amp;</span> y<span class="special">)</span><span class="special">;</span></pre>
798<p><span class="bold"><strong>Effects</strong></span>: Returns true if x is less than y</p>
799<p><span class="bold"><strong>Complexity</strong></span>: Linear to the number of elements in the container. </p>
800</li>
801<li class="listitem">
802<pre class="literallayout"><span class="keyword">friend</span> <span class="keyword">bool</span> <a name="idm45641213153440-bb"></a><span class="keyword">operator</span><span class="special">&gt;</span><span class="special">(</span><span class="keyword">const</span> <a class="link" href="multimap.html" title="Class template multimap">multimap</a> <span class="special">&amp;</span> x<span class="special">,</span> <span class="keyword">const</span> <a class="link" href="multimap.html" title="Class template multimap">multimap</a> <span class="special">&amp;</span> y<span class="special">)</span><span class="special">;</span></pre>
803<p><span class="bold"><strong>Effects</strong></span>: Returns true if x is greater than y</p>
804<p><span class="bold"><strong>Complexity</strong></span>: Linear to the number of elements in the container. </p>
805</li>
806<li class="listitem">
807<pre class="literallayout"><span class="keyword">friend</span> <span class="keyword">bool</span> <a name="idm45641213148448-bb"></a><span class="keyword">operator</span><span class="special">&lt;=</span><span class="special">(</span><span class="keyword">const</span> <a class="link" href="multimap.html" title="Class template multimap">multimap</a> <span class="special">&amp;</span> x<span class="special">,</span> <span class="keyword">const</span> <a class="link" href="multimap.html" title="Class template multimap">multimap</a> <span class="special">&amp;</span> y<span class="special">)</span><span class="special">;</span></pre>
808<p><span class="bold"><strong>Effects</strong></span>: Returns true if x is equal or less than y</p>
809<p><span class="bold"><strong>Complexity</strong></span>: Linear to the number of elements in the container. </p>
810</li>
811<li class="listitem">
812<pre class="literallayout"><span class="keyword">friend</span> <span class="keyword">bool</span> <a name="idm45641213143440-bb"></a><span class="keyword">operator</span><span class="special">&gt;=</span><span class="special">(</span><span class="keyword">const</span> <a class="link" href="multimap.html" title="Class template multimap">multimap</a> <span class="special">&amp;</span> x<span class="special">,</span> <span class="keyword">const</span> <a class="link" href="multimap.html" title="Class template multimap">multimap</a> <span class="special">&amp;</span> y<span class="special">)</span><span class="special">;</span></pre>
813<p><span class="bold"><strong>Effects</strong></span>: Returns true if x is equal or greater than y</p>
814<p><span class="bold"><strong>Complexity</strong></span>: Linear to the number of elements in the container. </p>
815</li>
816<li class="listitem">
817<pre class="literallayout"><span class="keyword">friend</span> <span class="keyword">void</span> <a name="idm45641213138432-bb"></a><span class="identifier">swap</span><span class="special">(</span><a class="link" href="multimap.html" title="Class template multimap">multimap</a> <span class="special">&amp;</span> x<span class="special">,</span> <a class="link" href="multimap.html" title="Class template multimap">multimap</a> <span class="special">&amp;</span> y<span class="special">)</span><span class="special">;</span></pre>
818<p><span class="bold"><strong>Effects</strong></span>: x.swap(y)</p>
819<p><span class="bold"><strong>Complexity</strong></span>: Constant. </p>
820</li>
821</ol></div>
822</div>
823</div>
824</div>
825<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
826<td align="left"></td>
827<td align="right"><div class="copyright-footer">Copyright © 2009-2018 Ion Gaztanaga<p>
828        Distributed under the Boost Software License, Version 1.0. (See accompanying
829        file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
830      </p>
831</div></td>
832</tr></table>
833<hr>
834<div class="spirit-nav">
835<a accesskey="p" href="map.html"><img src="../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../../boost_container_header_reference.html#header.boost.container.map_hpp"><img src="../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="pmr/map_of.html"><img src="../../../../doc/src/images/next.png" alt="Next"></a>
836</div>
837</body>
838</html>
839