doc/html/boost/container/multimap.html

   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=US-ASCII">
   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#idm45666070722704-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#idm45666070720192-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#idm45666070717056-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#idm45666070713936-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#idm45666070710384-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#idm45666070705872-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#idm45666070700640-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#idm45666070695392-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#idm45666070689456-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#idm45666070682384-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#idm45666070674592-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#idm45666070666096-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#idm45666070658304-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#idm45666070655280-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#idm45666070651536-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#idm45666070647792-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#idm45666070643344-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#idm45666070637792-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#idm45666070631520-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#idm45666070624592-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#idm45666070621328-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#idm45666070617008-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#idm45666070613056-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#idm45666070608448-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#idm45666070604608-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#idm45666070600496-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#idm45666071018576-bb">public member functions</a></span>
 105    <a class="link" href="multimap.html#idm45666071018016-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#idm45666071016576-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#idm45666071013568-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#idm45666071009152-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#idm45666071004448-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#idm45666071000880-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#idm45666070997024-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#idm45666070993168-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#idm45666070989344-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#idm45666070985520-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#idm45666070981696-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#idm45666070977840-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#idm45666070973984-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#idm45666070970128-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#idm45666070966272-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#idm45666070962416-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#idm45666070958560-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#idm45666070954736-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#idm45666070950896-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#idm45666070947072-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#idm45666070941456-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#idm45666070935152-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#idm45666070931728-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#idm45666070928256-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#idm45666070924800-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#idm45666070921344-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#idm45666070916224-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#idm45666070911072-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#idm45666070905936-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#idm45666070900800-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#idm45666070894944-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#idm45666070891456-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#idm45666070886912-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#idm45666070882272-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#idm45666070877904-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#idm45666070873600-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#idm45666070868624-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#idm45666070864304-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#idm45666070860016-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#idm45666070852528-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#idm45666070845040-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#idm45666070837552-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#idm45666070830064-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#idm45666070825168-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#idm45666070821376-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#idm45666070818384-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#idm45666070815376-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#idm45666070811920-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#idm45666070808192-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#idm45666070802976-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#idm45666070797488-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#idm45666070793824-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#idm45666070788400-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#idm45666070784688-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#idm45666070779216-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#idm45666070775760-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#idm45666070772032-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#idm45666070766816-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#idm45666070761328-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#idm45666070757872-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#idm45666070754144-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#idm45666070748928-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#idm45666070743440-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#idm45666070740000-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#idm45666070736272-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#idm45666070731072-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#idm45666070725584-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#idm45666070597936-bb">friend functions</a></span>
 178   <span class="keyword">friend</span> <span class="keyword">bool</span> <a class="link" href="multimap.html#idm45666070597376-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#idm45666070592384-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#idm45666070587392-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#idm45666070582400-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#idm45666070577408-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#idm45666070572400-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#idm45666070567392-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="idm45666070722704-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="idm45666070720192-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="idm45666070717056-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="idm45666070713936-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="idm45666070710384-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="idm45666070705872-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="idm45666070700640-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="idm45666070695392-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="idm45666070689456-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="idm45666070682384-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="idm45666070674592-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="idm45666070666096-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="idm45666070658304-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="idm45666070655280-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="idm45666070651536-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="idm45666070647792-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="idm45666070643344-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="idm45666070637792-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="idm45666070631520-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="idm45666070624592-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="idm45666070621328-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="idm45666070617008-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="idm45666070613056-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="idm45666070608448-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="idm45666070604608-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="idm45666070600496-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="idm45666071018576-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="idm45666071018016-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="idm45666071016576-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="idm45666071013568-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="idm45666071009152-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="idm45666071004448-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="idm45666071000880-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="idm45666070997024-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="idm45666070993168-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="idm45666070989344-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="idm45666070985520-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="idm45666070981696-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="idm45666070977840-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="idm45666070973984-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="idm45666070970128-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="idm45666070966272-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="idm45666070962416-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="idm45666070958560-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="idm45666070954736-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="idm45666070950896-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="idm45666070947072-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="idm45666070941456-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="idm45666070935152-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="idm45666070931728-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="idm45666070928256-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="idm45666070924800-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="idm45666070921344-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="idm45666070916224-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="idm45666070911072-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="idm45666070905936-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="idm45666070900800-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="idm45666070894944-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="idm45666070891456-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="idm45666070886912-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="idm45666070882272-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="idm45666070877904-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="idm45666070873600-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="idm45666070868624-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="idm45666070864304-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="idm45666070860016-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="idm45666070852528-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="idm45666070845040-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="idm45666070837552-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="idm45666070830064-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="idm45666070825168-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="idm45666070821376-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="idm45666070818384-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="idm45666070815376-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="idm45666070811920-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="idm45666070808192-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="idm45666070802976-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="idm45666070797488-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="idm45666070793824-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="idm45666070788400-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="idm45666070784688-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="idm45666070779216-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="idm45666070775760-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="idm45666070772032-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="idm45666070766816-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="idm45666070761328-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="idm45666070757872-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="idm45666070754144-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="idm45666070748928-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="idm45666070743440-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="idm45666070740000-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="idm45666070736272-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="idm45666070731072-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="idm45666070725584-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="idm45666070597936-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="idm45666070597376-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="idm45666070592384-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="idm45666070587392-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="idm45666070582400-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="idm45666070577408-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="idm45666070572400-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="idm45666070567392-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 &#169; 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>