doc/html/boost/container/static_vector.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 static_vector</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.static_vector_hpp" title="Header &lt;boost/container/static_vector.hpp&gt;">
  10 <link rel="prev" href="pmr/stable_vector_of.html" title="Struct template stable_vector_of">
  11 <link rel="next" href="operator_idm45666066728976.html" title="Function template operator==">
  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="pmr/stable_vector_of.html"><img src="../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../../boost_container_header_reference.html#header.boost.container.static_vector_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="operator_idm45666066728976.html"><img src="../../../../doc/src/images/next.png" alt="Next"></a>
  25 </div>
  26 <div class="refentry">
  27 <a name="boost.container.static_vector"></a><div class="titlepage"></div>
  28 <div class="refnamediv">
  29 <h2><span class="refentrytitle">Class template static_vector</span></h2>
  30 <p>boost::container::static_vector &#8212; A variable-size array container with fixed capacity. </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.static_vector_hpp" title="Header &lt;boost/container/static_vector.hpp&gt;">boost/container/static_vector.hpp</a>&gt;
  34
  35 </span><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> T<span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> Capacity<span class="special">,</span> <span class="keyword">typename</span> Options <span class="special">=</span> <span class="keyword">void</span><span class="special">&gt;</span>
  36 <span class="keyword">class</span> <a class="link" href="static_vector.html" title="Class template static_vector">static_vector</a> <span class="special">:</span> <span class="keyword">public</span> boost::container::vector&lt; T, dtl::get_static_vector_allocator&lt; T, Capacity, Options &gt;::type &gt;
  37 <span class="special">{</span>
  38 <span class="keyword">public</span><span class="special">:</span>
  39   <span class="comment">// types</span>
  40   <span class="keyword">typedef</span> <span class="identifier">base_t</span><span class="special">::</span><span class="identifier">value_type</span>             <a name="boost.container.static_vector.value_type"></a><span class="identifier">value_type</span><span class="special">;</span>              <span class="comment">// The type of elements stored in the container. </span>
  41   <span class="keyword">typedef</span> <span class="identifier">base_t</span><span class="special">::</span><span class="identifier">size_type</span>              <a name="boost.container.static_vector.size_type"></a><span class="identifier">size_type</span><span class="special">;</span>               <span class="comment">// The unsigned integral type used by the container. </span>
  42   <span class="keyword">typedef</span> <span class="identifier">base_t</span><span class="special">::</span><span class="identifier">difference_type</span>        <a name="boost.container.static_vector.difference_type"></a><span class="identifier">difference_type</span><span class="special">;</span>         <span class="comment">// The pointers difference type. </span>
  43   <span class="keyword">typedef</span> <span class="identifier">base_t</span><span class="special">::</span><span class="identifier">pointer</span>                <a name="boost.container.static_vector.pointer"></a><span class="identifier">pointer</span><span class="special">;</span>                 <span class="comment">// The pointer type. </span>
  44   <span class="keyword">typedef</span> <span class="identifier">base_t</span><span class="special">::</span><span class="identifier">const_pointer</span>          <a name="boost.container.static_vector.const_pointer"></a><span class="identifier">const_pointer</span><span class="special">;</span>           <span class="comment">// The const pointer type. </span>
  45   <span class="keyword">typedef</span> <span class="identifier">base_t</span><span class="special">::</span><span class="identifier">reference</span>              <a name="boost.container.static_vector.reference"></a><span class="identifier">reference</span><span class="special">;</span>               <span class="comment">// The value reference type. </span>
  46   <span class="keyword">typedef</span> <span class="identifier">base_t</span><span class="special">::</span><span class="identifier">const_reference</span>        <a name="boost.container.static_vector.const_reference"></a><span class="identifier">const_reference</span><span class="special">;</span>         <span class="comment">// The value const reference type. </span>
  47   <span class="keyword">typedef</span> <span class="identifier">base_t</span><span class="special">::</span><span class="identifier">iterator</span>               <a name="boost.container.static_vector.iterator"></a><span class="identifier">iterator</span><span class="special">;</span>                <span class="comment">// The iterator type. </span>
  48   <span class="keyword">typedef</span> <span class="identifier">base_t</span><span class="special">::</span><span class="identifier">const_iterator</span>         <a name="boost.container.static_vector.const_iterator"></a><span class="identifier">const_iterator</span><span class="special">;</span>          <span class="comment">// The const iterator type. </span>
  49   <span class="keyword">typedef</span> <span class="identifier">base_t</span><span class="special">::</span><span class="identifier">reverse_iterator</span>       <a name="boost.container.static_vector.reverse_iterator"></a><span class="identifier">reverse_iterator</span><span class="special">;</span>        <span class="comment">// The reverse iterator type. </span>
  50   <span class="keyword">typedef</span> <span class="identifier">base_t</span><span class="special">::</span><span class="identifier">const_reverse_iterator</span> <a name="boost.container.static_vector.const_reverse_iterator"></a><span class="identifier">const_reverse_iterator</span><span class="special">;</span>  <span class="comment">// The const reverse iterator. </span>
  51
  52   <span class="comment">// <a class="link" href="static_vector.html#boost.container.static_vectorconstruct-copy-destruct">construct/copy/destruct</a></span>
  53   <a class="link" href="static_vector.html#idm45666066869824-bb"><span class="identifier">static_vector</span></a><span class="special">(</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>
  54   <span class="keyword">explicit</span> <a class="link" href="static_vector.html#idm45666066865936-bb"><span class="identifier">static_vector</span></a><span class="special">(</span><span class="identifier">size_type</span><span class="special">)</span><span class="special">;</span>
  55   <a class="link" href="static_vector.html#idm45666066859984-bb"><span class="identifier">static_vector</span></a><span class="special">(</span><span class="identifier">size_type</span><span class="special">,</span> <a class="link" href="default_init_t.html" title="Struct default_init_t">default_init_t</a><span class="special">)</span><span class="special">;</span>
  56   <a class="link" href="static_vector.html#idm45666066852464-bb"><span class="identifier">static_vector</span></a><span class="special">(</span><span class="identifier">size_type</span><span class="special">,</span> <span class="identifier">value_type</span> <span class="keyword">const</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
  57   <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> Iterator<span class="special">&gt;</span> <a class="link" href="static_vector.html#idm45666066845648-bb"><span class="identifier">static_vector</span></a><span class="special">(</span><span class="identifier">Iterator</span><span class="special">,</span> <span class="identifier">Iterator</span><span class="special">)</span><span class="special">;</span>
  58   <a class="link" href="static_vector.html#idm45666066835120-bb"><span class="identifier">static_vector</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>
  59   <a class="link" href="static_vector.html#idm45666066827920-bb"><span class="identifier">static_vector</span></a><span class="special">(</span><a class="link" href="static_vector.html" title="Class template static_vector">static_vector</a> <span class="keyword">const</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
  60   <a class="link" href="static_vector.html#idm45666066821952-bb"><span class="identifier">static_vector</span></a><span class="special">(</span><a class="link" href="static_vector.html" title="Class template static_vector">static_vector</a> <span class="keyword">const</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>
  61   <a class="link" href="static_vector.html#idm45666066820000-bb"><span class="identifier">static_vector</span></a><span class="special">(</span><a class="link" href="static_vector.html" title="Class template static_vector">static_vector</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="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">value_type</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>
  62   <span class="keyword">explicit</span> <a class="link" href="static_vector.html#idm45666066817712-bb"><span class="identifier">static_vector</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>
  63   <span class="keyword">template</span><span class="special">&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> C<span class="special">,</span> <span class="keyword">typename</span> O<span class="special">&gt;</span>
  64     <a class="link" href="static_vector.html#idm45666066816464-bb"><span class="identifier">static_vector</span></a><span class="special">(</span><a class="link" href="static_vector.html" title="Class template static_vector">static_vector</a><span class="special">&lt;</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">C</span><span class="special">,</span> <span class="identifier">O</span> <span class="special">&gt;</span> <span class="keyword">const</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
  65   <a class="link" href="static_vector.html#idm45666066807920-bb"><span class="identifier">static_vector</span></a><span class="special">(</span><a class="link" href="static_vector.html" title="Class template static_vector">static_vector</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">value_type</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>
  66   <span class="keyword">template</span><span class="special">&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> C<span class="special">,</span> <span class="keyword">typename</span> O<span class="special">&gt;</span>
  67     <a class="link" href="static_vector.html#idm45666066798000-bb"><span class="identifier">static_vector</span></a><span class="special">(</span><a class="link" href="static_vector.html" title="Class template static_vector">static_vector</a><span class="special">&lt;</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">C</span><span class="special">,</span> <span class="identifier">O</span> <span class="special">&gt;</span> <span class="special">&amp;&amp;</span><span class="special">)</span><span class="special">;</span>
  68   <a class="link" href="static_vector.html" title="Class template static_vector">static_vector</a> <span class="special">&amp;</span> <a class="link" href="static_vector.html#idm45666066786000-bb"><span class="keyword">operator</span><span class="special">=</span></a><span class="special">(</span><span class="keyword">const</span> <a class="link" href="static_vector.html" title="Class template static_vector">static_vector</a> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
  69   <a class="link" href="static_vector.html" title="Class template static_vector">static_vector</a> <span class="special">&amp;</span> <a class="link" href="static_vector.html#idm45666066779264-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>
  70   <span class="keyword">template</span><span class="special">&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> C<span class="special">,</span> <span class="keyword">typename</span> O<span class="special">&gt;</span>
  71     <a class="link" href="static_vector.html" title="Class template static_vector">static_vector</a> <span class="special">&amp;</span> <a class="link" href="static_vector.html#idm45666066774400-bb"><span class="keyword">operator</span><span class="special">=</span></a><span class="special">(</span><a class="link" href="static_vector.html" title="Class template static_vector">static_vector</a><span class="special">&lt;</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">C</span><span class="special">,</span> <span class="identifier">O</span> <span class="special">&gt;</span> <span class="keyword">const</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
  72   <a class="link" href="static_vector.html" title="Class template static_vector">static_vector</a> <span class="special">&amp;</span>
  73   <a class="link" href="static_vector.html#idm45666066765408-bb"><span class="keyword">operator</span><span class="special">=</span></a><span class="special">(</span><a class="link" href="static_vector.html" title="Class template static_vector">static_vector</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_assignable</span><span class="special">&lt;</span> <span class="identifier">value_type</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>
  74   <span class="keyword">template</span><span class="special">&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> C<span class="special">,</span> <span class="keyword">typename</span> O<span class="special">&gt;</span>
  75     <a class="link" href="static_vector.html" title="Class template static_vector">static_vector</a> <span class="special">&amp;</span> <a class="link" href="static_vector.html#idm45666066754880-bb"><span class="keyword">operator</span><span class="special">=</span></a><span class="special">(</span><a class="link" href="static_vector.html" title="Class template static_vector">static_vector</a><span class="special">&lt;</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">C</span><span class="special">,</span> <span class="identifier">O</span> <span class="special">&gt;</span> <span class="special">&amp;&amp;</span><span class="special">)</span><span class="special">;</span>
  76   <a class="link" href="static_vector.html#idm45666066742272-bb"><span class="special">~</span><span class="identifier">static_vector</span></a><span class="special">(</span><span class="special">)</span><span class="special">;</span>
  77
  78   <span class="comment">// <a class="link" href="static_vector.html#idm45666067202976-bb">public member functions</a></span>
  79   <span class="keyword">void</span> <a class="link" href="static_vector.html#idm45666067202416-bb"><span class="identifier">swap</span></a><span class="special">(</span><a class="link" href="static_vector.html" title="Class template static_vector">static_vector</a> <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="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> C<span class="special">,</span> <span class="keyword">typename</span> O<span class="special">&gt;</span> <span class="keyword">void</span> <a class="link" href="static_vector.html#idm45666067192256-bb"><span class="identifier">swap</span></a><span class="special">(</span><a class="link" href="static_vector.html" title="Class template static_vector">static_vector</a><span class="special">&lt;</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">C</span><span class="special">,</span> <span class="identifier">O</span> <span class="special">&gt;</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
  81   <span class="keyword">void</span> <a class="link" href="static_vector.html#idm45666067179648-bb"><span class="identifier">resize</span></a><span class="special">(</span><span class="identifier">size_type</span><span class="special">)</span><span class="special">;</span>
  82   <span class="keyword">void</span> <a class="link" href="static_vector.html#idm45666067174080-bb"><span class="identifier">resize</span></a><span class="special">(</span><span class="identifier">size_type</span><span class="special">,</span> <a class="link" href="default_init_t.html" title="Struct default_init_t">default_init_t</a><span class="special">)</span><span class="special">;</span>
  83   <span class="keyword">void</span> <a class="link" href="static_vector.html#idm45666067166672-bb"><span class="identifier">resize</span></a><span class="special">(</span><span class="identifier">size_type</span><span class="special">,</span> <span class="identifier">value_type</span> <span class="keyword">const</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
  84   <span class="keyword">void</span> <a class="link" href="static_vector.html#idm45666067159968-bb"><span class="identifier">reserve</span></a><span class="special">(</span><span class="identifier">size_type</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>
  85   <span class="keyword">void</span> <a class="link" href="static_vector.html#idm45666067154176-bb"><span class="identifier">push_back</span></a><span class="special">(</span><span class="identifier">value_type</span> <span class="keyword">const</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
  86   <span class="keyword">void</span> <a class="link" href="static_vector.html#idm45666067148704-bb"><span class="identifier">push_back</span></a><span class="special">(</span><span class="identifier">value_type</span> <span class="special">&amp;&amp;</span><span class="special">)</span><span class="special">;</span>
  87   <span class="keyword">void</span> <a class="link" href="static_vector.html#idm45666067143232-bb"><span class="identifier">pop_back</span></a><span class="special">(</span><span class="special">)</span><span class="special">;</span>
  88   <span class="identifier">iterator</span> <a class="link" href="static_vector.html#idm45666067138896-bb"><span class="identifier">insert</span></a><span class="special">(</span><span class="identifier">const_iterator</span><span class="special">,</span> <span class="identifier">value_type</span> <span class="keyword">const</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
  89   <span class="identifier">iterator</span> <a class="link" href="static_vector.html#idm45666067127520-bb"><span class="identifier">insert</span></a><span class="special">(</span><span class="identifier">const_iterator</span><span class="special">,</span> <span class="identifier">value_type</span> <span class="special">&amp;&amp;</span><span class="special">)</span><span class="special">;</span>
  90   <span class="identifier">iterator</span> <a class="link" href="static_vector.html#idm45666067117920-bb"><span class="identifier">insert</span></a><span class="special">(</span><span class="identifier">const_iterator</span><span class="special">,</span> <span class="identifier">size_type</span><span class="special">,</span> <span class="identifier">value_type</span> <span class="keyword">const</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
  91   <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> Iterator<span class="special">&gt;</span>
  92     <span class="identifier">iterator</span> <a class="link" href="static_vector.html#idm45666067105392-bb"><span class="identifier">insert</span></a><span class="special">(</span><span class="identifier">const_iterator</span><span class="special">,</span> <span class="identifier">Iterator</span><span class="special">,</span> <span class="identifier">Iterator</span><span class="special">)</span><span class="special">;</span>
  93   <span class="identifier">iterator</span> <a class="link" href="static_vector.html#idm45666067089376-bb"><span class="identifier">insert</span></a><span class="special">(</span><span class="identifier">const_iterator</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><span class="special">)</span><span class="special">;</span>
  94   <span class="identifier">iterator</span> <a class="link" href="static_vector.html#idm45666067078208-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>
  95   <span class="identifier">iterator</span> <a class="link" href="static_vector.html#idm45666067071824-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>
  96   <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> Iterator<span class="special">&gt;</span> <span class="keyword">void</span> <a class="link" href="static_vector.html#idm45666067062000-bb"><span class="identifier">assign</span></a><span class="special">(</span><span class="identifier">Iterator</span><span class="special">,</span> <span class="identifier">Iterator</span><span class="special">)</span><span class="special">;</span>
  97   <span class="keyword">void</span> <a class="link" href="static_vector.html#idm45666067053952-bb"><span class="identifier">assign</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>
  98   <span class="keyword">void</span> <a class="link" href="static_vector.html#idm45666067047936-bb"><span class="identifier">assign</span></a><span class="special">(</span><span class="identifier">size_type</span><span class="special">,</span> <span class="identifier">value_type</span> <span class="keyword">const</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
  99   <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">reference</span> <a class="link" href="static_vector.html#idm45666067041264-bb"><span class="identifier">emplace_back</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>
 100   <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="static_vector.html#idm45666067033504-bb"><span class="identifier">emplace</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>
 101   <span class="keyword">void</span> <a class="link" href="static_vector.html#idm45666067022288-bb"><span class="identifier">clear</span></a><span class="special">(</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>
 102   <span class="identifier">reference</span> <a class="link" href="static_vector.html#idm45666067018544-bb"><span class="identifier">at</span></a><span class="special">(</span><span class="identifier">size_type</span><span class="special">)</span><span class="special">;</span>
 103   <span class="identifier">const_reference</span> <a class="link" href="static_vector.html#idm45666067012208-bb"><span class="identifier">at</span></a><span class="special">(</span><span class="identifier">size_type</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
 104   <span class="identifier">reference</span> <a class="link" href="static_vector.html#idm45666067005568-bb"><span class="keyword">operator</span><span class="special">[</span><span class="special">]</span></a><span class="special">(</span><span class="identifier">size_type</span><span class="special">)</span><span class="special">;</span>
 105   <span class="identifier">const_reference</span> <a class="link" href="static_vector.html#idm45666066999520-bb"><span class="keyword">operator</span><span class="special">[</span><span class="special">]</span></a><span class="special">(</span><span class="identifier">size_type</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
 106   <span class="identifier">iterator</span> <a class="link" href="static_vector.html#idm45666066993168-bb"><span class="identifier">nth</span></a><span class="special">(</span><span class="identifier">size_type</span><span class="special">)</span><span class="special">;</span>
 107   <span class="identifier">const_iterator</span> <a class="link" href="static_vector.html#idm45666066987136-bb"><span class="identifier">nth</span></a><span class="special">(</span><span class="identifier">size_type</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
 108   <span class="identifier">size_type</span> <a class="link" href="static_vector.html#idm45666066980832-bb"><span class="identifier">index_of</span></a><span class="special">(</span><span class="identifier">iterator</span><span class="special">)</span><span class="special">;</span>
 109   <span class="identifier">size_type</span> <a class="link" href="static_vector.html#idm45666066974784-bb"><span class="identifier">index_of</span></a><span class="special">(</span><span class="identifier">const_iterator</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
 110   <span class="identifier">reference</span> <a class="link" href="static_vector.html#idm45666066968464-bb"><span class="identifier">front</span></a><span class="special">(</span><span class="special">)</span><span class="special">;</span>
 111   <span class="identifier">const_reference</span> <a class="link" href="static_vector.html#idm45666066963344-bb"><span class="identifier">front</span></a><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
 112   <span class="identifier">reference</span> <a class="link" href="static_vector.html#idm45666066957936-bb"><span class="identifier">back</span></a><span class="special">(</span><span class="special">)</span><span class="special">;</span>
 113   <span class="identifier">const_reference</span> <a class="link" href="static_vector.html#idm45666066952832-bb"><span class="identifier">back</span></a><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
 114   <span class="identifier">T</span> <span class="special">*</span> <a class="link" href="static_vector.html#idm45666066947424-bb"><span class="identifier">data</span></a><span class="special">(</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>
 115   <span class="keyword">const</span> <span class="identifier">T</span> <span class="special">*</span> <a class="link" href="static_vector.html#idm45666066942768-bb"><span class="identifier">data</span></a><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span>
 116   <span class="identifier">iterator</span> <a class="link" href="static_vector.html#idm45666066938096-bb"><span class="identifier">begin</span></a><span class="special">(</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>
 117   <span class="identifier">const_iterator</span> <a class="link" href="static_vector.html#idm45666066933600-bb"><span class="identifier">begin</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">const_iterator</span> <a class="link" href="static_vector.html#idm45666066929072-bb"><span class="identifier">cbegin</span></a><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span>
 119   <span class="identifier">iterator</span> <a class="link" href="static_vector.html#idm45666066924544-bb"><span class="identifier">end</span></a><span class="special">(</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>
 120   <span class="identifier">const_iterator</span> <a class="link" href="static_vector.html#idm45666066920000-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>
 121   <span class="identifier">const_iterator</span> <a class="link" href="static_vector.html#idm45666066915440-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>
 122   <span class="identifier">reverse_iterator</span> <a class="link" href="static_vector.html#idm45666066910880-bb"><span class="identifier">rbegin</span></a><span class="special">(</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>
 123   <span class="identifier">const_reverse_iterator</span> <a class="link" href="static_vector.html#idm45666066905584-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>
 124   <span class="identifier">const_reverse_iterator</span> <a class="link" href="static_vector.html#idm45666066900288-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>
 125   <span class="identifier">reverse_iterator</span> <a class="link" href="static_vector.html#idm45666066894992-bb"><span class="identifier">rend</span></a><span class="special">(</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>
 126   <span class="identifier">const_reverse_iterator</span> <a class="link" href="static_vector.html#idm45666066889680-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>
 127   <span class="identifier">const_reverse_iterator</span> <a class="link" href="static_vector.html#idm45666066884352-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>
 128   <span class="identifier">size_type</span> <a class="link" href="static_vector.html#idm45666066879024-bb"><span class="identifier">size</span></a><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span>
 129   <span class="keyword">bool</span> <a class="link" href="static_vector.html#idm45666066874528-bb"><span class="identifier">empty</span></a><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span>
 130
 131   <span class="comment">// <a class="link" href="static_vector.html#idm45666066739360-bb">public static functions</a></span>
 132   <span class="keyword">static</span> <span class="identifier">size_type</span> <a class="link" href="static_vector.html#idm45666066738800-bb"><span class="identifier">capacity</span></a><span class="special">(</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>
 133   <span class="keyword">static</span> <span class="identifier">size_type</span> <a class="link" href="static_vector.html#idm45666066734064-bb"><span class="identifier">max_size</span></a><span class="special">(</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>
 134
 135   <span class="comment">// public data members</span>
 136   <span class="keyword">static</span> <span class="keyword">const</span> <span class="identifier">size_type</span> <span class="identifier">static_capacity</span><span class="special">;</span>  <span class="comment">// The capacity/max size of the container. </span>
 137 <span class="special">}</span><span class="special">;</span></pre></div>
 138 <div class="refsect1">
 139 <a name="id-1.3.10.14.38.3.4"></a><h2>Description</h2>
 140 <p><a class="link" href="static_vector.html" title="Class template static_vector">static_vector</a> is a sequence container like <a class="link" href="vector.html" title="Class template vector">boost::container::vector</a> with contiguous storage that can change in size, along with the static allocation, low overhead, and fixed capacity of boost::array.</p>
 141 <p>A <a class="link" href="static_vector.html" title="Class template static_vector">static_vector</a> is a sequence that supports random access to elements, constant time insertion and removal of elements at the end, and linear time insertion and removal of elements at the beginning or in the middle. The number of elements in a <a class="link" href="static_vector.html" title="Class template static_vector">static_vector</a> may vary dynamically up to a fixed capacity because elements are stored within the object itself similarly to an array. However, objects are initialized as they are inserted into <a class="link" href="static_vector.html" title="Class template static_vector">static_vector</a> unlike C arrays or std::array which must construct all elements on instantiation. The behavior of <a class="link" href="static_vector.html" title="Class template static_vector">static_vector</a> enables the use of statically allocated elements in cases with complex object lifetime requirements that would otherwise not be trivially possible.</p>
 142 <p><b>Error Handling.&#160;</b>Insertion beyond the capacity result in throwing std::bad_alloc() if exceptions are enabled or calling throw_bad_alloc() if not enabled.</p>
 143 <p>
 144 std::out_of_range is thrown if out of bounds access is performed in <code class="computeroutput">at()</code> if exceptions are enabled, throw_out_of_range() if not enabled.</p>
 145 <p>
 146 </p>
 147 <div class="refsect2">
 148 <a name="id-1.3.10.14.38.3.4.6"></a><h3>Template Parameters</h3>
 149 <div class="orderedlist"><ol class="orderedlist" type="1">
 150 <li class="listitem">
 151 <pre class="literallayout"><span class="keyword">typename</span> T</pre>
 152 <p>The type of element that will be stored. </p>
 153 </li>
 154 <li class="listitem">
 155 <pre class="literallayout"><span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> Capacity</pre>
 156 <p>The maximum number of elements <code class="computeroutput"><a class="link" href="static_vector.html" title="Class template static_vector">static_vector</a></code> can store, fixed at compile time. </p>
 157 </li>
 158 <li class="listitem">
 159 <pre class="literallayout"><span class="keyword">typename</span> Options <span class="special">=</span> <span class="keyword">void</span></pre>
 160 <p>A type produced from <code class="computeroutput"><code class="computeroutput"><a class="link" href="static_vector_options.html" title="Struct template static_vector_options">boost::container::static_vector_options</a></code></code>. </p>
 161 </li>
 162 </ol></div>
 163 </div>
 164 <div class="refsect2">
 165 <a name="id-1.3.10.14.38.3.4.7"></a><h3>
 166 <a name="boost.container.static_vectorconstruct-copy-destruct"></a><code class="computeroutput">static_vector</code>
 167         public
 168        construct/copy/destruct</h3>
 169 <div class="orderedlist"><ol class="orderedlist" type="1">
 170 <li class="listitem">
 171 <pre class="literallayout"><a name="idm45666066869824-bb"></a><span class="identifier">static_vector</span><span class="special">(</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span></pre>Constructs an empty <code class="computeroutput"><a class="link" href="static_vector.html" title="Class template static_vector">static_vector</a></code>. <p><b>Throws.&#160;</b>Nothing.</p>
 172 <p>
 173 </p>
 174 <p><b>Complexity.&#160;</b>Constant O(1). </p>
 175 <p>
 176 </p>
 177 </li>
 178 <li class="listitem">
 179 <pre class="literallayout"><span class="keyword">explicit</span> <a name="idm45666066865936-bb"></a><span class="identifier">static_vector</span><span class="special">(</span><span class="identifier">size_type</span> count<span class="special">)</span><span class="special">;</span></pre>Constructs a <code class="computeroutput"><a class="link" href="static_vector.html" title="Class template static_vector">static_vector</a></code> containing count value initialized values. <p>
 180
 181 </p>
 182 <p><b>Throws.&#160;</b>If T's value initialization throws.</p>
 183 <p>
 184 </p>
 185 <p><b>Complexity.&#160;</b>Linear O(N). </p>
 186 <p>
 187 </p>
 188 <div class="variablelist"><table border="0" class="variablelist compact">
 189 <colgroup>
 190 <col align="left" valign="top">
 191 <col>
 192 </colgroup>
 193 <tbody>
 194 <tr>
 195 <td><p><span class="term">Parameters:</span></p></td>
 196 <td><div class="variablelist"><table border="0" class="variablelist compact">
 197 <colgroup>
 198 <col align="left" valign="top">
 199 <col>
 200 </colgroup>
 201 <tbody><tr>
 202 <td><p><span class="term"><code class="computeroutput">count</code></span></p></td>
 203 <td><p>The number of values which will be contained in the container.</p></td>
 204 </tr></tbody>
 205 </table></div></td>
 206 </tr>
 207 <tr>
 208 <td><p><span class="term">Requires:</span></p></td>
 209 <td><p><code class="computeroutput">count &lt;= capacity()</code></p></td>
 210 </tr>
 211 </tbody>
 212 </table></div>
 213 </li>
 214 <li class="listitem">
 215 <pre class="literallayout"><a name="idm45666066859984-bb"></a><span class="identifier">static_vector</span><span class="special">(</span><span class="identifier">size_type</span> count<span class="special">,</span> <a class="link" href="default_init_t.html" title="Struct default_init_t">default_init_t</a><span class="special">)</span><span class="special">;</span></pre>Constructs a <code class="computeroutput"><a class="link" href="static_vector.html" title="Class template static_vector">static_vector</a></code> containing count default initialized values. <p>
 216
 217 </p>
 218 <p><b>Throws.&#160;</b>If T's default initialization throws.</p>
 219 <p>
 220 </p>
 221 <p><b>Complexity.&#160;</b>Linear O(N).</p>
 222 <p>
 223 </p>
 224 <p><b>Note.&#160;</b>Non-standard extension </p>
 225 <p>
 226 </p>
 227 <div class="variablelist"><table border="0" class="variablelist compact">
 228 <colgroup>
 229 <col align="left" valign="top">
 230 <col>
 231 </colgroup>
 232 <tbody>
 233 <tr>
 234 <td><p><span class="term">Parameters:</span></p></td>
 235 <td><div class="variablelist"><table border="0" class="variablelist compact">
 236 <colgroup>
 237 <col align="left" valign="top">
 238 <col>
 239 </colgroup>
 240 <tbody><tr>
 241 <td><p><span class="term"><code class="computeroutput">count</code></span></p></td>
 242 <td><p>The number of values which will be contained in the container.</p></td>
 243 </tr></tbody>
 244 </table></div></td>
 245 </tr>
 246 <tr>
 247 <td><p><span class="term">Requires:</span></p></td>
 248 <td><p><code class="computeroutput">count &lt;= capacity()</code></p></td>
 249 </tr>
 250 </tbody>
 251 </table></div>
 252 </li>
 253 <li class="listitem">
 254 <pre class="literallayout"><a name="idm45666066852464-bb"></a><span class="identifier">static_vector</span><span class="special">(</span><span class="identifier">size_type</span> count<span class="special">,</span> <span class="identifier">value_type</span> <span class="keyword">const</span> <span class="special">&amp;</span> value<span class="special">)</span><span class="special">;</span></pre>Constructs a <code class="computeroutput"><a class="link" href="static_vector.html" title="Class template static_vector">static_vector</a></code> containing count copies of value. <p>
 255
 256 </p>
 257 <p><b>Throws.&#160;</b>If T's copy constructor throws.</p>
 258 <p>
 259 </p>
 260 <p><b>Complexity.&#160;</b>Linear O(N). </p>
 261 <p>
 262 </p>
 263 <div class="variablelist"><table border="0" class="variablelist compact">
 264 <colgroup>
 265 <col align="left" valign="top">
 266 <col>
 267 </colgroup>
 268 <tbody>
 269 <tr>
 270 <td><p><span class="term">Parameters:</span></p></td>
 271 <td><div class="variablelist"><table border="0" class="variablelist compact">
 272 <colgroup>
 273 <col align="left" valign="top">
 274 <col>
 275 </colgroup>
 276 <tbody>
 277 <tr>
 278 <td><p><span class="term"><code class="computeroutput">count</code></span></p></td>
 279 <td><p>The number of copies of a values that will be contained in the container. </p></td>
 280 </tr>
 281 <tr>
 282 <td><p><span class="term"><code class="computeroutput">value</code></span></p></td>
 283 <td><p>The value which will be used to copy construct values.</p></td>
 284 </tr>
 285 </tbody>
 286 </table></div></td>
 287 </tr>
 288 <tr>
 289 <td><p><span class="term">Requires:</span></p></td>
 290 <td><p><code class="computeroutput">count &lt;= capacity()</code></p></td>
 291 </tr>
 292 </tbody>
 293 </table></div>
 294 </li>
 295 <li class="listitem">
 296 <pre class="literallayout"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> Iterator<span class="special">&gt;</span> <a name="idm45666066845648-bb"></a><span class="identifier">static_vector</span><span class="special">(</span><span class="identifier">Iterator</span> first<span class="special">,</span> <span class="identifier">Iterator</span> last<span class="special">)</span><span class="special">;</span></pre>Constructs a <code class="computeroutput"><a class="link" href="static_vector.html" title="Class template static_vector">static_vector</a></code> containing copy of a range <code class="computeroutput">[first, last)</code>. <p>
 297
 298 </p>
 299 <p><b>Throws.&#160;</b>If T's constructor taking a dereferenced Iterator throws.</p>
 300 <p>
 301 </p>
 302 <p><b>Complexity.&#160;</b>Linear O(N). </p>
 303 <p>
 304 </p>
 305 <div class="variablelist"><table border="0" class="variablelist compact">
 306 <colgroup>
 307 <col align="left" valign="top">
 308 <col>
 309 </colgroup>
 310 <tbody>
 311 <tr>
 312 <td><p><span class="term">Parameters:</span></p></td>
 313 <td><div class="variablelist"><table border="0" class="variablelist compact">
 314 <colgroup>
 315 <col align="left" valign="top">
 316 <col>
 317 </colgroup>
 318 <tbody>
 319 <tr>
 320 <td><p><span class="term"><code class="computeroutput">first</code></span></p></td>
 321 <td><p>The iterator to the first element in range. </p></td>
 322 </tr>
 323 <tr>
 324 <td><p><span class="term"><code class="computeroutput">last</code></span></p></td>
 325 <td><p>The iterator to the one after the last element in range.</p></td>
 326 </tr>
 327 </tbody>
 328 </table></div></td>
 329 </tr>
 330 <tr>
 331 <td><p><span class="term">Requires:</span></p></td>
 332 <td>
 333 <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
 334 <li class="listitem"><p><code class="computeroutput">distance(first, last) &lt;= capacity()</code> </p></li>
 335 <li class="listitem"><p>Iterator must meet the <code class="computeroutput">ForwardTraversalIterator</code> concept.</p></li>
 336 </ul></div>
 337 <p>
 338 </p>
 339 </td>
 340 </tr>
 341 </tbody>
 342 </table></div>
 343 </li>
 344 <li class="listitem">
 345 <pre class="literallayout"><a name="idm45666066835120-bb"></a><span class="identifier">static_vector</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>Constructs a <code class="computeroutput"><a class="link" href="static_vector.html" title="Class template static_vector">static_vector</a></code> containing copy of a range <code class="computeroutput">[il.begin(), il.end())</code>. <p>
 346
 347 </p>
 348 <p><b>Throws.&#160;</b>If T's constructor taking a dereferenced std::initializer_list throws.</p>
 349 <p>
 350 </p>
 351 <p><b>Complexity.&#160;</b>Linear O(N). </p>
 352 <p>
 353 </p>
 354 <div class="variablelist"><table border="0" class="variablelist compact">
 355 <colgroup>
 356 <col align="left" valign="top">
 357 <col>
 358 </colgroup>
 359 <tbody>
 360 <tr>
 361 <td><p><span class="term">Parameters:</span></p></td>
 362 <td><div class="variablelist"><table border="0" class="variablelist compact">
 363 <colgroup>
 364 <col align="left" valign="top">
 365 <col>
 366 </colgroup>
 367 <tbody><tr>
 368 <td><p><span class="term"><code class="computeroutput">il</code></span></p></td>
 369 <td><p>std::initializer_list with values to initialize vector.</p></td>
 370 </tr></tbody>
 371 </table></div></td>
 372 </tr>
 373 <tr>
 374 <td><p><span class="term">Requires:</span></p></td>
 375 <td>
 376 <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem"><p><code class="computeroutput">distance(il.begin(), il.end()) &lt;= capacity()</code></p></li></ul></div>
 377 <p>
 378 </p>
 379 </td>
 380 </tr>
 381 </tbody>
 382 </table></div>
 383 </li>
 384 <li class="listitem">
 385 <pre class="literallayout"><a name="idm45666066827920-bb"></a><span class="identifier">static_vector</span><span class="special">(</span><a class="link" href="static_vector.html" title="Class template static_vector">static_vector</a> <span class="keyword">const</span> <span class="special">&amp;</span> other<span class="special">)</span><span class="special">;</span></pre>Constructs a copy of other <code class="computeroutput"><a class="link" href="static_vector.html" title="Class template static_vector">static_vector</a></code>. <p>
 386 </p>
 387 <p><b>Throws.&#160;</b>If T's copy constructor throws.</p>
 388 <p>
 389 </p>
 390 <p><b>Complexity.&#160;</b>Linear O(N). </p>
 391 <p>
 392 </p>
 393 <div class="variablelist"><table border="0" class="variablelist compact">
 394 <colgroup>
 395 <col align="left" valign="top">
 396 <col>
 397 </colgroup>
 398 <tbody><tr>
 399 <td><p><span class="term">Parameters:</span></p></td>
 400 <td><div class="variablelist"><table border="0" class="variablelist compact">
 401 <colgroup>
 402 <col align="left" valign="top">
 403 <col>
 404 </colgroup>
 405 <tbody><tr>
 406 <td><p><span class="term"><code class="computeroutput">other</code></span></p></td>
 407 <td><p>The <code class="computeroutput"><a class="link" href="static_vector.html" title="Class template static_vector">static_vector</a></code> which content will be copied to this one.</p></td>
 408 </tr></tbody>
 409 </table></div></td>
 410 </tr></tbody>
 411 </table></div>
 412 </li>
 413 <li class="listitem"><pre class="literallayout"><a name="idm45666066821952-bb"></a><span class="identifier">static_vector</span><span class="special">(</span><a class="link" href="static_vector.html" title="Class template static_vector">static_vector</a> <span class="keyword">const</span> <span class="special">&amp;</span> other<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></pre></li>
 414 <li class="listitem"><pre class="literallayout"><a name="idm45666066820000-bb"></a><span class="identifier">static_vector</span><span class="special">(</span><a class="link" href="static_vector.html" title="Class template static_vector">static_vector</a> <span class="special">&amp;&amp;</span> other<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="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">value_type</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>
 415 <li class="listitem"><pre class="literallayout"><span class="keyword">explicit</span> <a name="idm45666066817712-bb"></a><span class="identifier">static_vector</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></pre></li>
 416 <li class="listitem">
 417 <pre class="literallayout"><span class="keyword">template</span><span class="special">&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> C<span class="special">,</span> <span class="keyword">typename</span> O<span class="special">&gt;</span>
 418   <a name="idm45666066816464-bb"></a><span class="identifier">static_vector</span><span class="special">(</span><a class="link" href="static_vector.html" title="Class template static_vector">static_vector</a><span class="special">&lt;</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">C</span><span class="special">,</span> <span class="identifier">O</span> <span class="special">&gt;</span> <span class="keyword">const</span> <span class="special">&amp;</span> other<span class="special">)</span><span class="special">;</span></pre>Constructs a copy of other <code class="computeroutput"><a class="link" href="static_vector.html" title="Class template static_vector">static_vector</a></code>. <p>
 419
 420 </p>
 421 <p><b>Throws.&#160;</b>If T's copy constructor throws.</p>
 422 <p>
 423 </p>
 424 <p><b>Complexity.&#160;</b>Linear O(N). </p>
 425 <p>
 426 </p>
 427 <div class="variablelist"><table border="0" class="variablelist compact">
 428 <colgroup>
 429 <col align="left" valign="top">
 430 <col>
 431 </colgroup>
 432 <tbody>
 433 <tr>
 434 <td><p><span class="term">Parameters:</span></p></td>
 435 <td><div class="variablelist"><table border="0" class="variablelist compact">
 436 <colgroup>
 437 <col align="left" valign="top">
 438 <col>
 439 </colgroup>
 440 <tbody><tr>
 441 <td><p><span class="term"><code class="computeroutput">other</code></span></p></td>
 442 <td><p>The <code class="computeroutput"><a class="link" href="static_vector.html" title="Class template static_vector">static_vector</a></code> which content will be copied to this one.</p></td>
 443 </tr></tbody>
 444 </table></div></td>
 445 </tr>
 446 <tr>
 447 <td><p><span class="term">Requires:</span></p></td>
 448 <td><p><code class="computeroutput">other.size() &lt;= capacity()</code>.</p></td>
 449 </tr>
 450 </tbody>
 451 </table></div>
 452 </li>
 453 <li class="listitem">
 454 <pre class="literallayout"><a name="idm45666066807920-bb"></a><span class="identifier">static_vector</span><span class="special">(</span><a class="link" href="static_vector.html" title="Class template static_vector">static_vector</a> <span class="special">&amp;&amp;</span> other<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">value_type</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>Move constructor. Moves Values stored in the other <code class="computeroutput"><a class="link" href="static_vector.html" title="Class template static_vector">static_vector</a></code> to this one. <p>
 455 </p>
 456 <p><b>Throws.&#160;</b></p>
 457 <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
 458 <li class="listitem"><p>If <code class="computeroutput">has_nothrow_move&lt;T&gt;::value</code> is <code class="computeroutput">true</code> and T's move constructor throws. </p></li>
 459 <li class="listitem"><p>If <code class="computeroutput">has_nothrow_move&lt;T&gt;::value</code> is <code class="computeroutput">false</code> and T's copy constructor throws.</p></li>
 460 </ul></div>
 461 <p>
 462 </p>
 463 <p>
 464 </p>
 465 <p><b>Complexity.&#160;</b>Linear O(N). </p>
 466 <p>
 467 </p>
 468 <div class="variablelist"><table border="0" class="variablelist compact">
 469 <colgroup>
 470 <col align="left" valign="top">
 471 <col>
 472 </colgroup>
 473 <tbody><tr>
 474 <td><p><span class="term">Parameters:</span></p></td>
 475 <td><div class="variablelist"><table border="0" class="variablelist compact">
 476 <colgroup>
 477 <col align="left" valign="top">
 478 <col>
 479 </colgroup>
 480 <tbody><tr>
 481 <td><p><span class="term"><code class="computeroutput">other</code></span></p></td>
 482 <td><p>The <code class="computeroutput"><a class="link" href="static_vector.html" title="Class template static_vector">static_vector</a></code> which content will be moved to this one.</p></td>
 483 </tr></tbody>
 484 </table></div></td>
 485 </tr></tbody>
 486 </table></div>
 487 </li>
 488 <li class="listitem">
 489 <pre class="literallayout"><span class="keyword">template</span><span class="special">&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> C<span class="special">,</span> <span class="keyword">typename</span> O<span class="special">&gt;</span>
 490   <a name="idm45666066798000-bb"></a><span class="identifier">static_vector</span><span class="special">(</span><a class="link" href="static_vector.html" title="Class template static_vector">static_vector</a><span class="special">&lt;</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">C</span><span class="special">,</span> <span class="identifier">O</span> <span class="special">&gt;</span> <span class="special">&amp;&amp;</span> other<span class="special">)</span><span class="special">;</span></pre>Move constructor. Moves Values stored in the other <code class="computeroutput"><a class="link" href="static_vector.html" title="Class template static_vector">static_vector</a></code> to this one. <p>
 491
 492 </p>
 493 <p><b>Throws.&#160;</b></p>
 494 <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
 495 <li class="listitem"><p>If <code class="computeroutput">has_nothrow_move&lt;T&gt;::value</code> is <code class="computeroutput">true</code> and T's move constructor throws. </p></li>
 496 <li class="listitem"><p>If <code class="computeroutput">has_nothrow_move&lt;T&gt;::value</code> is <code class="computeroutput">false</code> and T's copy constructor throws.</p></li>
 497 </ul></div>
 498 <p>
 499 </p>
 500 <p>
 501 </p>
 502 <p><b>Complexity.&#160;</b>Linear O(N). </p>
 503 <p>
 504 </p>
 505 <div class="variablelist"><table border="0" class="variablelist compact">
 506 <colgroup>
 507 <col align="left" valign="top">
 508 <col>
 509 </colgroup>
 510 <tbody>
 511 <tr>
 512 <td><p><span class="term">Parameters:</span></p></td>
 513 <td><div class="variablelist"><table border="0" class="variablelist compact">
 514 <colgroup>
 515 <col align="left" valign="top">
 516 <col>
 517 </colgroup>
 518 <tbody><tr>
 519 <td><p><span class="term"><code class="computeroutput">other</code></span></p></td>
 520 <td><p>The <code class="computeroutput"><a class="link" href="static_vector.html" title="Class template static_vector">static_vector</a></code> which content will be moved to this one.</p></td>
 521 </tr></tbody>
 522 </table></div></td>
 523 </tr>
 524 <tr>
 525 <td><p><span class="term">Requires:</span></p></td>
 526 <td><p><code class="computeroutput">other.size() &lt;= capacity()</code></p></td>
 527 </tr>
 528 </tbody>
 529 </table></div>
 530 </li>
 531 <li class="listitem">
 532 <pre class="literallayout"><a class="link" href="static_vector.html" title="Class template static_vector">static_vector</a> <span class="special">&amp;</span> <a name="idm45666066786000-bb"></a><span class="keyword">operator</span><span class="special">=</span><span class="special">(</span><span class="keyword">const</span> <a class="link" href="static_vector.html" title="Class template static_vector">static_vector</a> <span class="special">&amp;</span> other<span class="special">)</span><span class="special">;</span></pre>Copy assigns Values stored in the other <code class="computeroutput"><a class="link" href="static_vector.html" title="Class template static_vector">static_vector</a></code> to this one. <p>
 533 </p>
 534 <p><b>Throws.&#160;</b>If T's copy constructor or copy assignment throws.</p>
 535 <p>
 536 </p>
 537 <p><b>Complexity.&#160;</b>Linear O(N). </p>
 538 <p>
 539 </p>
 540 <div class="variablelist"><table border="0" class="variablelist compact">
 541 <colgroup>
 542 <col align="left" valign="top">
 543 <col>
 544 </colgroup>
 545 <tbody><tr>
 546 <td><p><span class="term">Parameters:</span></p></td>
 547 <td><div class="variablelist"><table border="0" class="variablelist compact">
 548 <colgroup>
 549 <col align="left" valign="top">
 550 <col>
 551 </colgroup>
 552 <tbody><tr>
 553 <td><p><span class="term"><code class="computeroutput">other</code></span></p></td>
 554 <td><p>The <code class="computeroutput"><a class="link" href="static_vector.html" title="Class template static_vector">static_vector</a></code> which content will be copied to this one.</p></td>
 555 </tr></tbody>
 556 </table></div></td>
 557 </tr></tbody>
 558 </table></div>
 559 </li>
 560 <li class="listitem">
 561 <pre class="literallayout"><a class="link" href="static_vector.html" title="Class template static_vector">static_vector</a> <span class="special">&amp;</span> <a name="idm45666066779264-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>Copy assigns Values stored in std::initializer_list to *this. <p>
 562 </p>
 563 <p><b>Throws.&#160;</b>If T's copy constructor or copy assignment throws.</p>
 564 <p>
 565 </p>
 566 <p><b>Complexity.&#160;</b>Linear O(N). </p>
 567 <p>
 568 </p>
 569 <div class="variablelist"><table border="0" class="variablelist compact">
 570 <colgroup>
 571 <col align="left" valign="top">
 572 <col>
 573 </colgroup>
 574 <tbody><tr>
 575 <td><p><span class="term">Parameters:</span></p></td>
 576 <td><div class="variablelist"><table border="0" class="variablelist compact">
 577 <colgroup>
 578 <col align="left" valign="top">
 579 <col>
 580 </colgroup>
 581 <tbody><tr>
 582 <td><p><span class="term"><code class="computeroutput">il</code></span></p></td>
 583 <td><p>The std::initializer_list which content will be copied to this one.</p></td>
 584 </tr></tbody>
 585 </table></div></td>
 586 </tr></tbody>
 587 </table></div>
 588 </li>
 589 <li class="listitem">
 590 <pre class="literallayout"><span class="keyword">template</span><span class="special">&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> C<span class="special">,</span> <span class="keyword">typename</span> O<span class="special">&gt;</span>
 591   <a class="link" href="static_vector.html" title="Class template static_vector">static_vector</a> <span class="special">&amp;</span> <a name="idm45666066774400-bb"></a><span class="keyword">operator</span><span class="special">=</span><span class="special">(</span><a class="link" href="static_vector.html" title="Class template static_vector">static_vector</a><span class="special">&lt;</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">C</span><span class="special">,</span> <span class="identifier">O</span> <span class="special">&gt;</span> <span class="keyword">const</span> <span class="special">&amp;</span> other<span class="special">)</span><span class="special">;</span></pre>Copy assigns Values stored in the other <code class="computeroutput"><a class="link" href="static_vector.html" title="Class template static_vector">static_vector</a></code> to this one. <p>
 592
 593 </p>
 594 <p><b>Throws.&#160;</b>If T's copy constructor or copy assignment throws.</p>
 595 <p>
 596 </p>
 597 <p><b>Complexity.&#160;</b>Linear O(N). </p>
 598 <p>
 599 </p>
 600 <div class="variablelist"><table border="0" class="variablelist compact">
 601 <colgroup>
 602 <col align="left" valign="top">
 603 <col>
 604 </colgroup>
 605 <tbody>
 606 <tr>
 607 <td><p><span class="term">Parameters:</span></p></td>
 608 <td><div class="variablelist"><table border="0" class="variablelist compact">
 609 <colgroup>
 610 <col align="left" valign="top">
 611 <col>
 612 </colgroup>
 613 <tbody><tr>
 614 <td><p><span class="term"><code class="computeroutput">other</code></span></p></td>
 615 <td><p>The <code class="computeroutput"><a class="link" href="static_vector.html" title="Class template static_vector">static_vector</a></code> which content will be copied to this one.</p></td>
 616 </tr></tbody>
 617 </table></div></td>
 618 </tr>
 619 <tr>
 620 <td><p><span class="term">Requires:</span></p></td>
 621 <td><p><code class="computeroutput">other.size() &lt;= capacity()</code></p></td>
 622 </tr>
 623 </tbody>
 624 </table></div>
 625 </li>
 626 <li class="listitem">
 627 <pre class="literallayout"><a class="link" href="static_vector.html" title="Class template static_vector">static_vector</a> <span class="special">&amp;</span>
 628 <a name="idm45666066765408-bb"></a><span class="keyword">operator</span><span class="special">=</span><span class="special">(</span><a class="link" href="static_vector.html" title="Class template static_vector">static_vector</a> <span class="special">&amp;&amp;</span> other<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_assignable</span><span class="special">&lt;</span> <span class="identifier">value_type</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>Move assignment. Moves Values stored in the other <code class="computeroutput"><a class="link" href="static_vector.html" title="Class template static_vector">static_vector</a></code> to this one. <p>
 629 </p>
 630 <p><b>Throws.&#160;</b></p>
 631 <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
 632 <li class="listitem"><p>If <code class="computeroutput">has_nothrow_move&lt;T&gt;::value</code> is <code class="computeroutput">true</code> and T's move constructor or move assignment throws. </p></li>
 633 <li class="listitem"><p>If <code class="computeroutput">has_nothrow_move&lt;T&gt;::value</code> is <code class="computeroutput">false</code> and T's copy constructor or copy assignment throws.</p></li>
 634 </ul></div>
 635 <p>
 636 </p>
 637 <p>
 638 </p>
 639 <p><b>Complexity.&#160;</b>Linear O(N). </p>
 640 <p>
 641 </p>
 642 <div class="variablelist"><table border="0" class="variablelist compact">
 643 <colgroup>
 644 <col align="left" valign="top">
 645 <col>
 646 </colgroup>
 647 <tbody><tr>
 648 <td><p><span class="term">Parameters:</span></p></td>
 649 <td><div class="variablelist"><table border="0" class="variablelist compact">
 650 <colgroup>
 651 <col align="left" valign="top">
 652 <col>
 653 </colgroup>
 654 <tbody><tr>
 655 <td><p><span class="term"><code class="computeroutput">other</code></span></p></td>
 656 <td><p>The <code class="computeroutput"><a class="link" href="static_vector.html" title="Class template static_vector">static_vector</a></code> which content will be moved to this one.</p></td>
 657 </tr></tbody>
 658 </table></div></td>
 659 </tr></tbody>
 660 </table></div>
 661 </li>
 662 <li class="listitem">
 663 <pre class="literallayout"><span class="keyword">template</span><span class="special">&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> C<span class="special">,</span> <span class="keyword">typename</span> O<span class="special">&gt;</span>
 664   <a class="link" href="static_vector.html" title="Class template static_vector">static_vector</a> <span class="special">&amp;</span> <a name="idm45666066754880-bb"></a><span class="keyword">operator</span><span class="special">=</span><span class="special">(</span><a class="link" href="static_vector.html" title="Class template static_vector">static_vector</a><span class="special">&lt;</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">C</span><span class="special">,</span> <span class="identifier">O</span> <span class="special">&gt;</span> <span class="special">&amp;&amp;</span> other<span class="special">)</span><span class="special">;</span></pre>Move assignment. Moves Values stored in the other <code class="computeroutput"><a class="link" href="static_vector.html" title="Class template static_vector">static_vector</a></code> to this one. <p>
 665
 666 </p>
 667 <p><b>Throws.&#160;</b></p>
 668 <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
 669 <li class="listitem"><p>If <code class="computeroutput">has_nothrow_move&lt;T&gt;::value</code> is <code class="computeroutput">true</code> and T's move constructor or move assignment throws. </p></li>
 670 <li class="listitem"><p>If <code class="computeroutput">has_nothrow_move&lt;T&gt;::value</code> is <code class="computeroutput">false</code> and T's copy constructor or copy assignment throws.</p></li>
 671 </ul></div>
 672 <p>
 673 </p>
 674 <p>
 675 </p>
 676 <p><b>Complexity.&#160;</b>Linear O(N). </p>
 677 <p>
 678 </p>
 679 <div class="variablelist"><table border="0" class="variablelist compact">
 680 <colgroup>
 681 <col align="left" valign="top">
 682 <col>
 683 </colgroup>
 684 <tbody>
 685 <tr>
 686 <td><p><span class="term">Parameters:</span></p></td>
 687 <td><div class="variablelist"><table border="0" class="variablelist compact">
 688 <colgroup>
 689 <col align="left" valign="top">
 690 <col>
 691 </colgroup>
 692 <tbody><tr>
 693 <td><p><span class="term"><code class="computeroutput">other</code></span></p></td>
 694 <td><p>The <code class="computeroutput"><a class="link" href="static_vector.html" title="Class template static_vector">static_vector</a></code> which content will be moved to this one.</p></td>
 695 </tr></tbody>
 696 </table></div></td>
 697 </tr>
 698 <tr>
 699 <td><p><span class="term">Requires:</span></p></td>
 700 <td><p><code class="computeroutput">other.size() &lt;= capacity()</code></p></td>
 701 </tr>
 702 </tbody>
 703 </table></div>
 704 </li>
 705 <li class="listitem">
 706 <pre class="literallayout"><a name="idm45666066742272-bb"></a><span class="special">~</span><span class="identifier">static_vector</span><span class="special">(</span><span class="special">)</span><span class="special">;</span></pre>Destructor. Destroys Values stored in this container. <p><b>Throws.&#160;</b>Nothing</p>
 707 <p>
 708 </p>
 709 <p><b>Complexity.&#160;</b>Linear O(N). </p>
 710 <p>
 711 </p>
 712 </li>
 713 </ol></div>
 714 </div>
 715 <div class="refsect2">
 716 <a name="id-1.3.10.14.38.3.4.8"></a><h3>
 717 <a name="idm45666067202976-bb"></a><code class="computeroutput">static_vector</code> public member functions</h3>
 718 <div class="orderedlist"><ol class="orderedlist" type="1">
 719 <li class="listitem">
 720 <pre class="literallayout"><span class="keyword">void</span> <a name="idm45666067202416-bb"></a><span class="identifier">swap</span><span class="special">(</span><a class="link" href="static_vector.html" title="Class template static_vector">static_vector</a> <span class="special">&amp;</span> other<span class="special">)</span><span class="special">;</span></pre>Swaps contents of the other <code class="computeroutput"><a class="link" href="static_vector.html" title="Class template static_vector">static_vector</a></code> and this one. <p>
 721 </p>
 722 <p><b>Throws.&#160;</b></p>
 723 <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
 724 <li class="listitem"><p>If <code class="computeroutput">has_nothrow_move&lt;T&gt;::value</code> is <code class="computeroutput">true</code> and T's move constructor or move assignment throws, </p></li>
 725 <li class="listitem"><p>If <code class="computeroutput">has_nothrow_move&lt;T&gt;::value</code> is <code class="computeroutput">false</code> and T's copy constructor or copy assignment throws,</p></li>
 726 </ul></div>
 727 <p>
 728 </p>
 729 <p>
 730 </p>
 731 <p><b>Complexity.&#160;</b>Linear O(N). </p>
 732 <p>
 733 </p>
 734 <div class="variablelist"><table border="0" class="variablelist compact">
 735 <colgroup>
 736 <col align="left" valign="top">
 737 <col>
 738 </colgroup>
 739 <tbody><tr>
 740 <td><p><span class="term">Parameters:</span></p></td>
 741 <td><div class="variablelist"><table border="0" class="variablelist compact">
 742 <colgroup>
 743 <col align="left" valign="top">
 744 <col>
 745 </colgroup>
 746 <tbody><tr>
 747 <td><p><span class="term"><code class="computeroutput">other</code></span></p></td>
 748 <td><p>The <code class="computeroutput"><a class="link" href="static_vector.html" title="Class template static_vector">static_vector</a></code> which content will be swapped with this one's content.</p></td>
 749 </tr></tbody>
 750 </table></div></td>
 751 </tr></tbody>
 752 </table></div>
 753 </li>
 754 <li class="listitem">
 755 <pre class="literallayout"><span class="keyword">template</span><span class="special">&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> C<span class="special">,</span> <span class="keyword">typename</span> O<span class="special">&gt;</span>
 756   <span class="keyword">void</span> <a name="idm45666067192256-bb"></a><span class="identifier">swap</span><span class="special">(</span><a class="link" href="static_vector.html" title="Class template static_vector">static_vector</a><span class="special">&lt;</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">C</span><span class="special">,</span> <span class="identifier">O</span> <span class="special">&gt;</span> <span class="special">&amp;</span> other<span class="special">)</span><span class="special">;</span></pre>Swaps contents of the other <code class="computeroutput"><a class="link" href="static_vector.html" title="Class template static_vector">static_vector</a></code> and this one. <p>
 757
 758 </p>
 759 <p><b>Throws.&#160;</b></p>
 760 <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
 761 <li class="listitem"><p>If <code class="computeroutput">has_nothrow_move&lt;T&gt;::value</code> is <code class="computeroutput">true</code> and T's move constructor or move assignment throws, </p></li>
 762 <li class="listitem"><p>If <code class="computeroutput">has_nothrow_move&lt;T&gt;::value</code> is <code class="computeroutput">false</code> and T's copy constructor or copy assignment throws,</p></li>
 763 </ul></div>
 764 <p>
 765 </p>
 766 <p>
 767 </p>
 768 <p><b>Complexity.&#160;</b>Linear O(N). </p>
 769 <p>
 770 </p>
 771 <div class="variablelist"><table border="0" class="variablelist compact">
 772 <colgroup>
 773 <col align="left" valign="top">
 774 <col>
 775 </colgroup>
 776 <tbody>
 777 <tr>
 778 <td><p><span class="term">Parameters:</span></p></td>
 779 <td><div class="variablelist"><table border="0" class="variablelist compact">
 780 <colgroup>
 781 <col align="left" valign="top">
 782 <col>
 783 </colgroup>
 784 <tbody><tr>
 785 <td><p><span class="term"><code class="computeroutput">other</code></span></p></td>
 786 <td><p>The <code class="computeroutput"><a class="link" href="static_vector.html" title="Class template static_vector">static_vector</a></code> which content will be swapped with this one's content.</p></td>
 787 </tr></tbody>
 788 </table></div></td>
 789 </tr>
 790 <tr>
 791 <td><p><span class="term">Requires:</span></p></td>
 792 <td><p><code class="computeroutput">other.size() &lt;= capacity() &amp;&amp; size() &lt;= other.capacity()</code></p></td>
 793 </tr>
 794 </tbody>
 795 </table></div>
 796 </li>
 797 <li class="listitem">
 798 <pre class="literallayout"><span class="keyword">void</span> <a name="idm45666067179648-bb"></a><span class="identifier">resize</span><span class="special">(</span><span class="identifier">size_type</span> count<span class="special">)</span><span class="special">;</span></pre>Inserts or erases elements at the end such that the size becomes count. New elements are value initialized. <p>
 799
 800 </p>
 801 <p><b>Throws.&#160;</b>If T's value initialization throws.</p>
 802 <p>
 803 </p>
 804 <p><b>Complexity.&#160;</b>Linear O(N). </p>
 805 <p>
 806 </p>
 807 <div class="variablelist"><table border="0" class="variablelist compact">
 808 <colgroup>
 809 <col align="left" valign="top">
 810 <col>
 811 </colgroup>
 812 <tbody>
 813 <tr>
 814 <td><p><span class="term">Parameters:</span></p></td>
 815 <td><div class="variablelist"><table border="0" class="variablelist compact">
 816 <colgroup>
 817 <col align="left" valign="top">
 818 <col>
 819 </colgroup>
 820 <tbody><tr>
 821 <td><p><span class="term"><code class="computeroutput">count</code></span></p></td>
 822 <td><p>The number of elements which will be stored in the container.</p></td>
 823 </tr></tbody>
 824 </table></div></td>
 825 </tr>
 826 <tr>
 827 <td><p><span class="term">Requires:</span></p></td>
 828 <td><p><code class="computeroutput">count &lt;= capacity()</code></p></td>
 829 </tr>
 830 </tbody>
 831 </table></div>
 832 </li>
 833 <li class="listitem">
 834 <pre class="literallayout"><span class="keyword">void</span> <a name="idm45666067174080-bb"></a><span class="identifier">resize</span><span class="special">(</span><span class="identifier">size_type</span> count<span class="special">,</span> <a class="link" href="default_init_t.html" title="Struct default_init_t">default_init_t</a><span class="special">)</span><span class="special">;</span></pre>Inserts or erases elements at the end such that the size becomes count. New elements are default initialized. <p>
 835
 836 </p>
 837 <p><b>Throws.&#160;</b>If T's default initialization throws.</p>
 838 <p>
 839 </p>
 840 <p><b>Complexity.&#160;</b>Linear O(N).</p>
 841 <p>
 842 </p>
 843 <p><b>Note.&#160;</b>Non-standard extension </p>
 844 <p>
 845 </p>
 846 <div class="variablelist"><table border="0" class="variablelist compact">
 847 <colgroup>
 848 <col align="left" valign="top">
 849 <col>
 850 </colgroup>
 851 <tbody>
 852 <tr>
 853 <td><p><span class="term">Parameters:</span></p></td>
 854 <td><div class="variablelist"><table border="0" class="variablelist compact">
 855 <colgroup>
 856 <col align="left" valign="top">
 857 <col>
 858 </colgroup>
 859 <tbody><tr>
 860 <td><p><span class="term"><code class="computeroutput">count</code></span></p></td>
 861 <td><p>The number of elements which will be stored in the container.</p></td>
 862 </tr></tbody>
 863 </table></div></td>
 864 </tr>
 865 <tr>
 866 <td><p><span class="term">Requires:</span></p></td>
 867 <td><p><code class="computeroutput">count &lt;= capacity()</code></p></td>
 868 </tr>
 869 </tbody>
 870 </table></div>
 871 </li>
 872 <li class="listitem">
 873 <pre class="literallayout"><span class="keyword">void</span> <a name="idm45666067166672-bb"></a><span class="identifier">resize</span><span class="special">(</span><span class="identifier">size_type</span> count<span class="special">,</span> <span class="identifier">value_type</span> <span class="keyword">const</span> <span class="special">&amp;</span> value<span class="special">)</span><span class="special">;</span></pre>Inserts or erases elements at the end such that the size becomes count. New elements are copy constructed from value. <p>
 874
 875 </p>
 876 <p><b>Throws.&#160;</b>If T's copy constructor throws.</p>
 877 <p>
 878 </p>
 879 <p><b>Complexity.&#160;</b>Linear O(N). </p>
 880 <p>
 881 </p>
 882 <div class="variablelist"><table border="0" class="variablelist compact">
 883 <colgroup>
 884 <col align="left" valign="top">
 885 <col>
 886 </colgroup>
 887 <tbody>
 888 <tr>
 889 <td><p><span class="term">Parameters:</span></p></td>
 890 <td><div class="variablelist"><table border="0" class="variablelist compact">
 891 <colgroup>
 892 <col align="left" valign="top">
 893 <col>
 894 </colgroup>
 895 <tbody>
 896 <tr>
 897 <td><p><span class="term"><code class="computeroutput">count</code></span></p></td>
 898 <td><p>The number of elements which will be stored in the container. </p></td>
 899 </tr>
 900 <tr>
 901 <td><p><span class="term"><code class="computeroutput">value</code></span></p></td>
 902 <td><p>The value used to copy construct the new element.</p></td>
 903 </tr>
 904 </tbody>
 905 </table></div></td>
 906 </tr>
 907 <tr>
 908 <td><p><span class="term">Requires:</span></p></td>
 909 <td><p><code class="computeroutput">count &lt;= capacity()</code></p></td>
 910 </tr>
 911 </tbody>
 912 </table></div>
 913 </li>
 914 <li class="listitem">
 915 <pre class="literallayout"><span class="keyword">void</span> <a name="idm45666067159968-bb"></a><span class="identifier">reserve</span><span class="special">(</span><span class="identifier">size_type</span> count<span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span></pre>This call has no effect because the Capacity of this container is constant. <p>
 916
 917 </p>
 918 <p><b>Throws.&#160;</b>Nothing.</p>
 919 <p>
 920 </p>
 921 <p><b>Complexity.&#160;</b>Linear O(N). </p>
 922 <p>
 923 </p>
 924 <div class="variablelist"><table border="0" class="variablelist compact">
 925 <colgroup>
 926 <col align="left" valign="top">
 927 <col>
 928 </colgroup>
 929 <tbody>
 930 <tr>
 931 <td><p><span class="term">Parameters:</span></p></td>
 932 <td><div class="variablelist"><table border="0" class="variablelist compact">
 933 <colgroup>
 934 <col align="left" valign="top">
 935 <col>
 936 </colgroup>
 937 <tbody><tr>
 938 <td><p><span class="term"><code class="computeroutput">count</code></span></p></td>
 939 <td><p>The number of elements which the container should be able to contain.</p></td>
 940 </tr></tbody>
 941 </table></div></td>
 942 </tr>
 943 <tr>
 944 <td><p><span class="term">Requires:</span></p></td>
 945 <td><p><code class="computeroutput">count &lt;= capacity()</code></p></td>
 946 </tr>
 947 </tbody>
 948 </table></div>
 949 </li>
 950 <li class="listitem">
 951 <pre class="literallayout"><span class="keyword">void</span> <a name="idm45666067154176-bb"></a><span class="identifier">push_back</span><span class="special">(</span><span class="identifier">value_type</span> <span class="keyword">const</span> <span class="special">&amp;</span> value<span class="special">)</span><span class="special">;</span></pre>Adds a copy of value at the end. <p>
 952
 953 </p>
 954 <p><b>Throws.&#160;</b>If T's copy constructor throws.</p>
 955 <p>
 956 </p>
 957 <p><b>Complexity.&#160;</b>Constant O(1). </p>
 958 <p>
 959 </p>
 960 <div class="variablelist"><table border="0" class="variablelist compact">
 961 <colgroup>
 962 <col align="left" valign="top">
 963 <col>
 964 </colgroup>
 965 <tbody>
 966 <tr>
 967 <td><p><span class="term">Parameters:</span></p></td>
 968 <td><div class="variablelist"><table border="0" class="variablelist compact">
 969 <colgroup>
 970 <col align="left" valign="top">
 971 <col>
 972 </colgroup>
 973 <tbody><tr>
 974 <td><p><span class="term"><code class="computeroutput">value</code></span></p></td>
 975 <td><p>The value used to copy construct the new element.</p></td>
 976 </tr></tbody>
 977 </table></div></td>
 978 </tr>
 979 <tr>
 980 <td><p><span class="term">Requires:</span></p></td>
 981 <td><p><code class="computeroutput">size() &lt; capacity()</code></p></td>
 982 </tr>
 983 </tbody>
 984 </table></div>
 985 </li>
 986 <li class="listitem">
 987 <pre class="literallayout"><span class="keyword">void</span> <a name="idm45666067148704-bb"></a><span class="identifier">push_back</span><span class="special">(</span><span class="identifier">value_type</span> <span class="special">&amp;&amp;</span> value<span class="special">)</span><span class="special">;</span></pre>Moves value to the end. <p>
 988
 989 </p>
 990 <p><b>Throws.&#160;</b>If T's move constructor throws.</p>
 991 <p>
 992 </p>
 993 <p><b>Complexity.&#160;</b>Constant O(1). </p>
 994 <p>
 995 </p>
 996 <div class="variablelist"><table border="0" class="variablelist compact">
 997 <colgroup>
 998 <col align="left" valign="top">
 999 <col>
1000 </colgroup>
1001 <tbody>
1002 <tr>
1003 <td><p><span class="term">Parameters:</span></p></td>
1004 <td><div class="variablelist"><table border="0" class="variablelist compact">
1005 <colgroup>
1006 <col align="left" valign="top">
1007 <col>
1008 </colgroup>
1009 <tbody><tr>
1010 <td><p><span class="term"><code class="computeroutput">value</code></span></p></td>
1011 <td><p>The value to move construct the new element.</p></td>
1012 </tr></tbody>
1013 </table></div></td>
1014 </tr>
1015 <tr>
1016 <td><p><span class="term">Requires:</span></p></td>
1017 <td><p><code class="computeroutput">size() &lt; capacity()</code></p></td>
1018 </tr>
1019 </tbody>
1020 </table></div>
1021 </li>
1022 <li class="listitem">
1023 <pre class="literallayout"><span class="keyword">void</span> <a name="idm45666067143232-bb"></a><span class="identifier">pop_back</span><span class="special">(</span><span class="special">)</span><span class="special">;</span></pre>Destroys last value and decreases the size. <p>
1024 </p>
1025 <p><b>Throws.&#160;</b>Nothing by default.</p>
1026 <p>
1027 </p>
1028 <p><b>Complexity.&#160;</b>Constant O(1). </p>
1029 <p>
1030 </p>
1031 <div class="variablelist"><table border="0" class="variablelist compact">
1032 <colgroup>
1033 <col align="left" valign="top">
1034 <col>
1035 </colgroup>
1036 <tbody><tr>
1037 <td><p><span class="term">Requires:</span></p></td>
1038 <td><p><code class="computeroutput">!empty()</code></p></td>
1039 </tr></tbody>
1040 </table></div>
1041 </li>
1042 <li class="listitem">
1043 <pre class="literallayout"><span class="identifier">iterator</span> <a name="idm45666067138896-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">value_type</span> <span class="keyword">const</span> <span class="special">&amp;</span> value<span class="special">)</span><span class="special">;</span></pre>Inserts a copy of element at p. <p>
1044
1045 </p>
1046 <p><b>Throws.&#160;</b></p>
1047 <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
1048 <li class="listitem"><p>If T's copy constructor or copy assignment throws </p></li>
1049 <li class="listitem"><p>If T's move constructor or move assignment throws.</p></li>
1050 </ul></div>
1051 <p>
1052 </p>
1053 <p>
1054 </p>
1055 <p><b>Complexity.&#160;</b>Constant or linear. </p>
1056 <p>
1057 </p>
1058 <div class="variablelist"><table border="0" class="variablelist compact">
1059 <colgroup>
1060 <col align="left" valign="top">
1061 <col>
1062 </colgroup>
1063 <tbody>
1064 <tr>
1065 <td><p><span class="term">Parameters:</span></p></td>
1066 <td><div class="variablelist"><table border="0" class="variablelist compact">
1067 <colgroup>
1068 <col align="left" valign="top">
1069 <col>
1070 </colgroup>
1071 <tbody>
1072 <tr>
1073 <td><p><span class="term"><code class="computeroutput">p</code></span></p></td>
1074 <td><p>The position at which the new value will be inserted. </p></td>
1075 </tr>
1076 <tr>
1077 <td><p><span class="term"><code class="computeroutput">value</code></span></p></td>
1078 <td><p>The value used to copy construct the new element.</p></td>
1079 </tr>
1080 </tbody>
1081 </table></div></td>
1082 </tr>
1083 <tr>
1084 <td><p><span class="term">Requires:</span></p></td>
1085 <td>
1086 <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
1087 <li class="listitem"><p><code class="computeroutput">p</code> must be a valid iterator of <code class="computeroutput">*this</code> in range <code class="computeroutput">[begin(), end()]</code>. </p></li>
1088 <li class="listitem"><p><code class="computeroutput">size() &lt; capacity()</code></p></li>
1089 </ul></div>
1090 <p>
1091 </p>
1092 </td>
1093 </tr>
1094 </tbody>
1095 </table></div>
1096 </li>
1097 <li class="listitem">
1098 <pre class="literallayout"><span class="identifier">iterator</span> <a name="idm45666067127520-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">value_type</span> <span class="special">&amp;&amp;</span> value<span class="special">)</span><span class="special">;</span></pre>Inserts a move-constructed element at p. <p>
1099
1100 </p>
1101 <p><b>Throws.&#160;</b>If T's move constructor or move assignment throws.</p>
1102 <p>
1103 </p>
1104 <p><b>Complexity.&#160;</b>Constant or linear. </p>
1105 <p>
1106 </p>
1107 <div class="variablelist"><table border="0" class="variablelist compact">
1108 <colgroup>
1109 <col align="left" valign="top">
1110 <col>
1111 </colgroup>
1112 <tbody>
1113 <tr>
1114 <td><p><span class="term">Parameters:</span></p></td>
1115 <td><div class="variablelist"><table border="0" class="variablelist compact">
1116 <colgroup>
1117 <col align="left" valign="top">
1118 <col>
1119 </colgroup>
1120 <tbody>
1121 <tr>
1122 <td><p><span class="term"><code class="computeroutput">p</code></span></p></td>
1123 <td><p>The position at which the new value will be inserted. </p></td>
1124 </tr>
1125 <tr>
1126 <td><p><span class="term"><code class="computeroutput">value</code></span></p></td>
1127 <td><p>The value used to move construct the new element.</p></td>
1128 </tr>
1129 </tbody>
1130 </table></div></td>
1131 </tr>
1132 <tr>
1133 <td><p><span class="term">Requires:</span></p></td>
1134 <td>
1135 <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
1136 <li class="listitem"><p><code class="computeroutput">p</code> must be a valid iterator of <code class="computeroutput">*this</code> in range <code class="computeroutput">[begin(), end()]</code>. </p></li>
1137 <li class="listitem"><p><code class="computeroutput">size() &lt; capacity()</code></p></li>
1138 </ul></div>
1139 <p>
1140 </p>
1141 </td>
1142 </tr>
1143 </tbody>
1144 </table></div>
1145 </li>
1146 <li class="listitem">
1147 <pre class="literallayout"><span class="identifier">iterator</span> <a name="idm45666067117920-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">size_type</span> count<span class="special">,</span> <span class="identifier">value_type</span> <span class="keyword">const</span> <span class="special">&amp;</span> value<span class="special">)</span><span class="special">;</span></pre>Inserts a count copies of value at p. <p>
1148
1149 </p>
1150 <p><b>Throws.&#160;</b></p>
1151 <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
1152 <li class="listitem"><p>If T's copy constructor or copy assignment throws. </p></li>
1153 <li class="listitem"><p>If T's move constructor or move assignment throws.</p></li>
1154 </ul></div>
1155 <p>
1156 </p>
1157 <p>
1158 </p>
1159 <p><b>Complexity.&#160;</b>Linear O(N). </p>
1160 <p>
1161 </p>
1162 <div class="variablelist"><table border="0" class="variablelist compact">
1163 <colgroup>
1164 <col align="left" valign="top">
1165 <col>
1166 </colgroup>
1167 <tbody>
1168 <tr>
1169 <td><p><span class="term">Parameters:</span></p></td>
1170 <td><div class="variablelist"><table border="0" class="variablelist compact">
1171 <colgroup>
1172 <col align="left" valign="top">
1173 <col>
1174 </colgroup>
1175 <tbody>
1176 <tr>
1177 <td><p><span class="term"><code class="computeroutput">count</code></span></p></td>
1178 <td><p>The number of new elements which will be inserted. </p></td>
1179 </tr>
1180 <tr>
1181 <td><p><span class="term"><code class="computeroutput">p</code></span></p></td>
1182 <td><p>The position at which new elements will be inserted. </p></td>
1183 </tr>
1184 <tr>
1185 <td><p><span class="term"><code class="computeroutput">value</code></span></p></td>
1186 <td><p>The value used to copy construct new elements.</p></td>
1187 </tr>
1188 </tbody>
1189 </table></div></td>
1190 </tr>
1191 <tr>
1192 <td><p><span class="term">Requires:</span></p></td>
1193 <td>
1194 <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
1195 <li class="listitem"><p><code class="computeroutput">p</code> must be a valid iterator of <code class="computeroutput">*this</code> in range <code class="computeroutput">[begin(), end()]</code>. </p></li>
1196 <li class="listitem"><p><code class="computeroutput">size() + count &lt;= capacity()</code></p></li>
1197 </ul></div>
1198 <p>
1199 </p>
1200 </td>
1201 </tr>
1202 </tbody>
1203 </table></div>
1204 </li>
1205 <li class="listitem">
1206 <pre class="literallayout"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> Iterator<span class="special">&gt;</span>
1207   <span class="identifier">iterator</span> <a name="idm45666067105392-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">Iterator</span> first<span class="special">,</span> <span class="identifier">Iterator</span> last<span class="special">)</span><span class="special">;</span></pre>Inserts a copy of a range <code class="computeroutput">[first, last)</code> at p. <p>
1208
1209 </p>
1210 <p><b>Throws.&#160;</b></p>
1211 <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
1212 <li class="listitem"><p>If T's constructor and assignment taking a dereferenced <code class="computeroutput">Iterator</code>. </p></li>
1213 <li class="listitem"><p>If T's move constructor or move assignment throws.</p></li>
1214 </ul></div>
1215 <p>
1216 </p>
1217 <p>
1218 </p>
1219 <p><b>Complexity.&#160;</b>Linear O(N). </p>
1220 <p>
1221 </p>
1222 <div class="variablelist"><table border="0" class="variablelist compact">
1223 <colgroup>
1224 <col align="left" valign="top">
1225 <col>
1226 </colgroup>
1227 <tbody>
1228 <tr>
1229 <td><p><span class="term">Parameters:</span></p></td>
1230 <td><div class="variablelist"><table border="0" class="variablelist compact">
1231 <colgroup>
1232 <col align="left" valign="top">
1233 <col>
1234 </colgroup>
1235 <tbody>
1236 <tr>
1237 <td><p><span class="term"><code class="computeroutput">first</code></span></p></td>
1238 <td><p>The iterator to the first element of a range used to construct new elements. </p></td>
1239 </tr>
1240 <tr>
1241 <td><p><span class="term"><code class="computeroutput">last</code></span></p></td>
1242 <td><p>The iterator to the one after the last element of a range used to construct new elements.</p></td>
1243 </tr>
1244 <tr>
1245 <td><p><span class="term"><code class="computeroutput">p</code></span></p></td>
1246 <td><p>The position at which new elements will be inserted. </p></td>
1247 </tr>
1248 </tbody>
1249 </table></div></td>
1250 </tr>
1251 <tr>
1252 <td><p><span class="term">Requires:</span></p></td>
1253 <td>
1254 <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
1255 <li class="listitem"><p><code class="computeroutput">p</code> must be a valid iterator of <code class="computeroutput">*this</code> in range <code class="computeroutput">[begin(), end()]</code>. </p></li>
1256 <li class="listitem"><p><code class="computeroutput">distance(first, last) &lt;= capacity()</code> </p></li>
1257 <li class="listitem"><p><code class="computeroutput">Iterator</code> must meet the <code class="computeroutput">ForwardTraversalIterator</code> concept.</p></li>
1258 </ul></div>
1259 <p>
1260 </p>
1261 </td>
1262 </tr>
1263 </tbody>
1264 </table></div>
1265 </li>
1266 <li class="listitem">
1267 <pre class="literallayout"><span class="identifier">iterator</span> <a name="idm45666067089376-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">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>Inserts a copy of a range <code class="computeroutput">[il.begin(), il.end())</code> at p. <p>
1268
1269 </p>
1270 <p><b>Throws.&#160;</b></p>
1271 <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem"><p>If T's constructor and assignment taking a dereferenced std::initializer_list iterator.</p></li></ul></div>
1272 <p>
1273 </p>
1274 <p>
1275 </p>
1276 <p><b>Complexity.&#160;</b>Linear O(N). </p>
1277 <p>
1278 </p>
1279 <div class="variablelist"><table border="0" class="variablelist compact">
1280 <colgroup>
1281 <col align="left" valign="top">
1282 <col>
1283 </colgroup>
1284 <tbody>
1285 <tr>
1286 <td><p><span class="term">Parameters:</span></p></td>
1287 <td><div class="variablelist"><table border="0" class="variablelist compact">
1288 <colgroup>
1289 <col align="left" valign="top">
1290 <col>
1291 </colgroup>
1292 <tbody>
1293 <tr>
1294 <td><p><span class="term"><code class="computeroutput">il</code></span></p></td>
1295 <td><p>The std::initializer_list which contains elements that will be inserted.</p></td>
1296 </tr>
1297 <tr>
1298 <td><p><span class="term"><code class="computeroutput">p</code></span></p></td>
1299 <td><p>The position at which new elements will be inserted. </p></td>
1300 </tr>
1301 </tbody>
1302 </table></div></td>
1303 </tr>
1304 <tr>
1305 <td><p><span class="term">Requires:</span></p></td>
1306 <td>
1307 <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
1308 <li class="listitem"><p><code class="computeroutput">p</code> must be a valid iterator of <code class="computeroutput">*this</code> in range <code class="computeroutput">[begin(), end()]</code>. </p></li>
1309 <li class="listitem"><p><code class="computeroutput">distance(il.begin(), il.end()) &lt;= capacity()</code></p></li>
1310 </ul></div>
1311 <p>
1312 </p>
1313 </td>
1314 </tr>
1315 </tbody>
1316 </table></div>
1317 </li>
1318 <li class="listitem">
1319 <pre class="literallayout"><span class="identifier">iterator</span> <a name="idm45666067078208-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>Erases T from p. <p>
1320
1321 </p>
1322 <p><b>Throws.&#160;</b>If T's move assignment throws.</p>
1323 <p>
1324 </p>
1325 <p><b>Complexity.&#160;</b>Linear O(N). </p>
1326 <p>
1327 </p>
1328 <div class="variablelist"><table border="0" class="variablelist compact">
1329 <colgroup>
1330 <col align="left" valign="top">
1331 <col>
1332 </colgroup>
1333 <tbody>
1334 <tr>
1335 <td><p><span class="term">Parameters:</span></p></td>
1336 <td><div class="variablelist"><table border="0" class="variablelist compact">
1337 <colgroup>
1338 <col align="left" valign="top">
1339 <col>
1340 </colgroup>
1341 <tbody><tr>
1342 <td><p><span class="term"><code class="computeroutput">p</code></span></p></td>
1343 <td><p>The position of the element which will be erased from the container.</p></td>
1344 </tr></tbody>
1345 </table></div></td>
1346 </tr>
1347 <tr>
1348 <td><p><span class="term">Requires:</span></p></td>
1349 <td><p><code class="computeroutput">p</code> must be a valid iterator of <code class="computeroutput">*this</code> in range <code class="computeroutput">[begin(), end())</code></p></td>
1350 </tr>
1351 </tbody>
1352 </table></div>
1353 </li>
1354 <li class="listitem">
1355 <pre class="literallayout"><span class="identifier">iterator</span> <a name="idm45666067071824-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>Erases Values from a range <code class="computeroutput">[first, last)</code>. <p>
1356
1357 </p>
1358 <p><b>Throws.&#160;</b>If T's move assignment throws.</p>
1359 <p>
1360 </p>
1361 <p><b>Complexity.&#160;</b>Linear O(N). </p>
1362 <p>
1363 </p>
1364 <div class="variablelist"><table border="0" class="variablelist compact">
1365 <colgroup>
1366 <col align="left" valign="top">
1367 <col>
1368 </colgroup>
1369 <tbody>
1370 <tr>
1371 <td><p><span class="term">Parameters:</span></p></td>
1372 <td><div class="variablelist"><table border="0" class="variablelist compact">
1373 <colgroup>
1374 <col align="left" valign="top">
1375 <col>
1376 </colgroup>
1377 <tbody>
1378 <tr>
1379 <td><p><span class="term"><code class="computeroutput">first</code></span></p></td>
1380 <td><p>The position of the first element of a range which will be erased from the container. </p></td>
1381 </tr>
1382 <tr>
1383 <td><p><span class="term"><code class="computeroutput">last</code></span></p></td>
1384 <td><p>The position of the one after the last element of a range which will be erased from the container.</p></td>
1385 </tr>
1386 </tbody>
1387 </table></div></td>
1388 </tr>
1389 <tr>
1390 <td><p><span class="term">Requires:</span></p></td>
1391 <td>
1392 <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
1393 <li class="listitem"><p><code class="computeroutput">first</code> and <code class="computeroutput">last</code> must define a valid range </p></li>
1394 <li class="listitem"><p>iterators must be in range <code class="computeroutput">[begin(), end()]</code></p></li>
1395 </ul></div>
1396 <p>
1397 </p>
1398 </td>
1399 </tr>
1400 </tbody>
1401 </table></div>
1402 </li>
1403 <li class="listitem">
1404 <pre class="literallayout"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> Iterator<span class="special">&gt;</span> <span class="keyword">void</span> <a name="idm45666067062000-bb"></a><span class="identifier">assign</span><span class="special">(</span><span class="identifier">Iterator</span> first<span class="special">,</span> <span class="identifier">Iterator</span> last<span class="special">)</span><span class="special">;</span></pre>Assigns a range <code class="computeroutput">[first, last)</code> of Values to this container. <p>
1405
1406 </p>
1407 <p><b>Throws.&#160;</b>If T's copy constructor or copy assignment throws,</p>
1408 <p>
1409 </p>
1410 <p><b>Complexity.&#160;</b>Linear O(N). </p>
1411 <p>
1412 </p>
1413 <div class="variablelist"><table border="0" class="variablelist compact">
1414 <colgroup>
1415 <col align="left" valign="top">
1416 <col>
1417 </colgroup>
1418 <tbody>
1419 <tr>
1420 <td><p><span class="term">Parameters:</span></p></td>
1421 <td><div class="variablelist"><table border="0" class="variablelist compact">
1422 <colgroup>
1423 <col align="left" valign="top">
1424 <col>
1425 </colgroup>
1426 <tbody>
1427 <tr>
1428 <td><p><span class="term"><code class="computeroutput">first</code></span></p></td>
1429 <td><p>The iterator to the first element of a range used to construct new content of this container. </p></td>
1430 </tr>
1431 <tr>
1432 <td><p><span class="term"><code class="computeroutput">last</code></span></p></td>
1433 <td><p>The iterator to the one after the last element of a range used to construct new content of this container.</p></td>
1434 </tr>
1435 </tbody>
1436 </table></div></td>
1437 </tr>
1438 <tr>
1439 <td><p><span class="term">Requires:</span></p></td>
1440 <td><p><code class="computeroutput">distance(first, last) &lt;= capacity()</code></p></td>
1441 </tr>
1442 </tbody>
1443 </table></div>
1444 </li>
1445 <li class="listitem">
1446 <pre class="literallayout"><span class="keyword">void</span> <a name="idm45666067053952-bb"></a><span class="identifier">assign</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>Assigns a range <code class="computeroutput">[il.begin(), il.end())</code> of Values to this container. <p>
1447
1448 </p>
1449 <p><b>Throws.&#160;</b>If T's copy constructor or copy assignment throws,</p>
1450 <p>
1451 </p>
1452 <p><b>Complexity.&#160;</b>Linear O(N). </p>
1453 <p>
1454 </p>
1455 <div class="variablelist"><table border="0" class="variablelist compact">
1456 <colgroup>
1457 <col align="left" valign="top">
1458 <col>
1459 </colgroup>
1460 <tbody>
1461 <tr>
1462 <td><p><span class="term">Parameters:</span></p></td>
1463 <td><div class="variablelist"><table border="0" class="variablelist compact">
1464 <colgroup>
1465 <col align="left" valign="top">
1466 <col>
1467 </colgroup>
1468 <tbody><tr>
1469 <td><p><span class="term"><code class="computeroutput">il</code></span></p></td>
1470 <td><p>std::initializer_list with values used to construct new content of this container.</p></td>
1471 </tr></tbody>
1472 </table></div></td>
1473 </tr>
1474 <tr>
1475 <td><p><span class="term">Requires:</span></p></td>
1476 <td><p><code class="computeroutput">distance(il.begin(), il.end()) &lt;= capacity()</code></p></td>
1477 </tr>
1478 </tbody>
1479 </table></div>
1480 </li>
1481 <li class="listitem">
1482 <pre class="literallayout"><span class="keyword">void</span> <a name="idm45666067047936-bb"></a><span class="identifier">assign</span><span class="special">(</span><span class="identifier">size_type</span> count<span class="special">,</span> <span class="identifier">value_type</span> <span class="keyword">const</span> <span class="special">&amp;</span> value<span class="special">)</span><span class="special">;</span></pre>Assigns a count copies of value to this container. <p>
1483
1484 </p>
1485 <p><b>Throws.&#160;</b>If T's copy constructor or copy assignment throws.</p>
1486 <p>
1487 </p>
1488 <p><b>Complexity.&#160;</b>Linear O(N). </p>
1489 <p>
1490 </p>
1491 <div class="variablelist"><table border="0" class="variablelist compact">
1492 <colgroup>
1493 <col align="left" valign="top">
1494 <col>
1495 </colgroup>
1496 <tbody>
1497 <tr>
1498 <td><p><span class="term">Parameters:</span></p></td>
1499 <td><div class="variablelist"><table border="0" class="variablelist compact">
1500 <colgroup>
1501 <col align="left" valign="top">
1502 <col>
1503 </colgroup>
1504 <tbody>
1505 <tr>
1506 <td><p><span class="term"><code class="computeroutput">count</code></span></p></td>
1507 <td><p>The new number of elements which will be container in the container. </p></td>
1508 </tr>
1509 <tr>
1510 <td><p><span class="term"><code class="computeroutput">value</code></span></p></td>
1511 <td><p>The value which will be used to copy construct the new content.</p></td>
1512 </tr>
1513 </tbody>
1514 </table></div></td>
1515 </tr>
1516 <tr>
1517 <td><p><span class="term">Requires:</span></p></td>
1518 <td><p><code class="computeroutput">count &lt;= capacity()</code></p></td>
1519 </tr>
1520 </tbody>
1521 </table></div>
1522 </li>
1523 <li class="listitem">
1524 <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">reference</span> <a name="idm45666067041264-bb"></a><span class="identifier">emplace_back</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>Inserts a T constructed with <code class="computeroutput">std::forward&lt;Args&gt;(args)</code>... in the end of the container. <p>
1525
1526
1527 </p>
1528 <p><b>Throws.&#160;</b>If in-place constructor throws or T's move constructor throws.</p>
1529 <p>
1530 </p>
1531 <p><b>Complexity.&#160;</b>Constant O(1). </p>
1532 <p>
1533 </p>
1534 <div class="variablelist"><table border="0" class="variablelist compact">
1535 <colgroup>
1536 <col align="left" valign="top">
1537 <col>
1538 </colgroup>
1539 <tbody>
1540 <tr>
1541 <td><p><span class="term">Parameters:</span></p></td>
1542 <td><div class="variablelist"><table border="0" class="variablelist compact">
1543 <colgroup>
1544 <col align="left" valign="top">
1545 <col>
1546 </colgroup>
1547 <tbody><tr>
1548 <td><p><span class="term"><code class="computeroutput">args</code></span></p></td>
1549 <td><p>The arguments of the constructor of the new element which will be created at the end of the container.</p></td>
1550 </tr></tbody>
1551 </table></div></td>
1552 </tr>
1553 <tr>
1554 <td><p><span class="term">Requires:</span></p></td>
1555 <td><p><code class="computeroutput">size() &lt; capacity()</code></p></td>
1556 </tr>
1557 <tr>
1558 <td><p><span class="term">Returns:</span></p></td>
1559 <td><p>A reference to the created object.</p></td>
1560 </tr>
1561 </tbody>
1562 </table></div>
1563 </li>
1564 <li class="listitem">
1565 <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="idm45666067033504-bb"></a><span class="identifier">emplace</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>Inserts a T constructed with <code class="computeroutput">std::forward&lt;Args&gt;(args)</code>... before p. <p>
1566
1567 </p>
1568 <p><b>Throws.&#160;</b>If in-place constructor throws or if T's move constructor or move assignment throws.</p>
1569 <p>
1570 </p>
1571 <p><b>Complexity.&#160;</b>Constant or linear. </p>
1572 <p>
1573 </p>
1574 <div class="variablelist"><table border="0" class="variablelist compact">
1575 <colgroup>
1576 <col align="left" valign="top">
1577 <col>
1578 </colgroup>
1579 <tbody>
1580 <tr>
1581 <td><p><span class="term">Parameters:</span></p></td>
1582 <td><div class="variablelist"><table border="0" class="variablelist compact">
1583 <colgroup>
1584 <col align="left" valign="top">
1585 <col>
1586 </colgroup>
1587 <tbody>
1588 <tr>
1589 <td><p><span class="term"><code class="computeroutput">args</code></span></p></td>
1590 <td><p>The arguments of the constructor of the new element.</p></td>
1591 </tr>
1592 <tr>
1593 <td><p><span class="term"><code class="computeroutput">p</code></span></p></td>
1594 <td><p>The position at which new elements will be inserted. </p></td>
1595 </tr>
1596 </tbody>
1597 </table></div></td>
1598 </tr>
1599 <tr>
1600 <td><p><span class="term">Requires:</span></p></td>
1601 <td>
1602 <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
1603 <li class="listitem"><p><code class="computeroutput">p</code> must be a valid iterator of <code class="computeroutput">*this</code> in range <code class="computeroutput">[begin(), end()]</code> </p></li>
1604 <li class="listitem"><p><code class="computeroutput">size() &lt; capacity()</code></p></li>
1605 </ul></div>
1606 <p>
1607 </p>
1608 </td>
1609 </tr>
1610 </tbody>
1611 </table></div>
1612 </li>
1613 <li class="listitem">
1614 <pre class="literallayout"><span class="keyword">void</span> <a name="idm45666067022288-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>Removes all elements from the container. <p><b>Throws.&#160;</b>Nothing.</p>
1615 <p>
1616 </p>
1617 <p><b>Complexity.&#160;</b>Constant O(1). </p>
1618 <p>
1619 </p>
1620 </li>
1621 <li class="listitem">
1622 <pre class="literallayout"><span class="identifier">reference</span> <a name="idm45666067018544-bb"></a><span class="identifier">at</span><span class="special">(</span><span class="identifier">size_type</span> i<span class="special">)</span><span class="special">;</span></pre>Returns reference to the i-th element. <p>
1623
1624
1625 </p>
1626 <p><b>Throws.&#160;</b><code class="computeroutput">std::out_of_range</code> exception by default.</p>
1627 <p>
1628 </p>
1629 <p><b>Complexity.&#160;</b>Constant O(1). </p>
1630 <p>
1631 </p>
1632 <div class="variablelist"><table border="0" class="variablelist compact">
1633 <colgroup>
1634 <col align="left" valign="top">
1635 <col>
1636 </colgroup>
1637 <tbody>
1638 <tr>
1639 <td><p><span class="term">Parameters:</span></p></td>
1640 <td><div class="variablelist"><table border="0" class="variablelist compact">
1641 <colgroup>
1642 <col align="left" valign="top">
1643 <col>
1644 </colgroup>
1645 <tbody><tr>
1646 <td><p><span class="term"><code class="computeroutput">i</code></span></p></td>
1647 <td><p>The element's index.</p></td>
1648 </tr></tbody>
1649 </table></div></td>
1650 </tr>
1651 <tr>
1652 <td><p><span class="term">Requires:</span></p></td>
1653 <td><p><code class="computeroutput">i &lt; size()</code></p></td>
1654 </tr>
1655 <tr>
1656 <td><p><span class="term">Returns:</span></p></td>
1657 <td><p>reference to the i-th element from the beginning of the container.</p></td>
1658 </tr>
1659 </tbody>
1660 </table></div>
1661 </li>
1662 <li class="listitem">
1663 <pre class="literallayout"><span class="identifier">const_reference</span> <a name="idm45666067012208-bb"></a><span class="identifier">at</span><span class="special">(</span><span class="identifier">size_type</span> i<span class="special">)</span> <span class="keyword">const</span><span class="special">;</span></pre>Returns const reference to the i-th element. <p>
1664
1665
1666 </p>
1667 <p><b>Throws.&#160;</b><code class="computeroutput">std::out_of_range</code> exception by default.</p>
1668 <p>
1669 </p>
1670 <p><b>Complexity.&#160;</b>Constant O(1). </p>
1671 <p>
1672 </p>
1673 <div class="variablelist"><table border="0" class="variablelist compact">
1674 <colgroup>
1675 <col align="left" valign="top">
1676 <col>
1677 </colgroup>
1678 <tbody>
1679 <tr>
1680 <td><p><span class="term">Parameters:</span></p></td>
1681 <td><div class="variablelist"><table border="0" class="variablelist compact">
1682 <colgroup>
1683 <col align="left" valign="top">
1684 <col>
1685 </colgroup>
1686 <tbody><tr>
1687 <td><p><span class="term"><code class="computeroutput">i</code></span></p></td>
1688 <td><p>The element's index.</p></td>
1689 </tr></tbody>
1690 </table></div></td>
1691 </tr>
1692 <tr>
1693 <td><p><span class="term">Requires:</span></p></td>
1694 <td><p><code class="computeroutput">i &lt; size()</code></p></td>
1695 </tr>
1696 <tr>
1697 <td><p><span class="term">Returns:</span></p></td>
1698 <td><p>const reference to the i-th element from the beginning of the container.</p></td>
1699 </tr>
1700 </tbody>
1701 </table></div>
1702 </li>
1703 <li class="listitem">
1704 <pre class="literallayout"><span class="identifier">reference</span> <a name="idm45666067005568-bb"></a><span class="keyword">operator</span><span class="special">[</span><span class="special">]</span><span class="special">(</span><span class="identifier">size_type</span> i<span class="special">)</span><span class="special">;</span></pre>Returns reference to the i-th element. <p>
1705
1706
1707 </p>
1708 <p><b>Throws.&#160;</b>Nothing by default.</p>
1709 <p>
1710 </p>
1711 <p><b>Complexity.&#160;</b>Constant O(1). </p>
1712 <p>
1713 </p>
1714 <div class="variablelist"><table border="0" class="variablelist compact">
1715 <colgroup>
1716 <col align="left" valign="top">
1717 <col>
1718 </colgroup>
1719 <tbody>
1720 <tr>
1721 <td><p><span class="term">Parameters:</span></p></td>
1722 <td><div class="variablelist"><table border="0" class="variablelist compact">
1723 <colgroup>
1724 <col align="left" valign="top">
1725 <col>
1726 </colgroup>
1727 <tbody><tr>
1728 <td><p><span class="term"><code class="computeroutput">i</code></span></p></td>
1729 <td><p>The element's index.</p></td>
1730 </tr></tbody>
1731 </table></div></td>
1732 </tr>
1733 <tr>
1734 <td><p><span class="term">Requires:</span></p></td>
1735 <td><p><code class="computeroutput">i &lt; size()</code></p></td>
1736 </tr>
1737 <tr>
1738 <td><p><span class="term">Returns:</span></p></td>
1739 <td><p>reference to the i-th element from the beginning of the container.</p></td>
1740 </tr>
1741 </tbody>
1742 </table></div>
1743 </li>
1744 <li class="listitem">
1745 <pre class="literallayout"><span class="identifier">const_reference</span> <a name="idm45666066999520-bb"></a><span class="keyword">operator</span><span class="special">[</span><span class="special">]</span><span class="special">(</span><span class="identifier">size_type</span> i<span class="special">)</span> <span class="keyword">const</span><span class="special">;</span></pre>Returns const reference to the i-th element. <p>
1746
1747
1748 </p>
1749 <p><b>Throws.&#160;</b>Nothing by default.</p>
1750 <p>
1751 </p>
1752 <p><b>Complexity.&#160;</b>Constant O(1). </p>
1753 <p>
1754 </p>
1755 <div class="variablelist"><table border="0" class="variablelist compact">
1756 <colgroup>
1757 <col align="left" valign="top">
1758 <col>
1759 </colgroup>
1760 <tbody>
1761 <tr>
1762 <td><p><span class="term">Parameters:</span></p></td>
1763 <td><div class="variablelist"><table border="0" class="variablelist compact">
1764 <colgroup>
1765 <col align="left" valign="top">
1766 <col>
1767 </colgroup>
1768 <tbody><tr>
1769 <td><p><span class="term"><code class="computeroutput">i</code></span></p></td>
1770 <td><p>The element's index.</p></td>
1771 </tr></tbody>
1772 </table></div></td>
1773 </tr>
1774 <tr>
1775 <td><p><span class="term">Requires:</span></p></td>
1776 <td><p><code class="computeroutput">i &lt; size()</code></p></td>
1777 </tr>
1778 <tr>
1779 <td><p><span class="term">Returns:</span></p></td>
1780 <td><p>const reference to the i-th element from the beginning of the container.</p></td>
1781 </tr>
1782 </tbody>
1783 </table></div>
1784 </li>
1785 <li class="listitem">
1786 <pre class="literallayout"><span class="identifier">iterator</span> <a name="idm45666066993168-bb"></a><span class="identifier">nth</span><span class="special">(</span><span class="identifier">size_type</span> i<span class="special">)</span><span class="special">;</span></pre>Returns a iterator to the i-th element. <p>
1787
1788
1789 </p>
1790 <p><b>Throws.&#160;</b>Nothing by default.</p>
1791 <p>
1792 </p>
1793 <p><b>Complexity.&#160;</b>Constant O(1). </p>
1794 <p>
1795 </p>
1796 <div class="variablelist"><table border="0" class="variablelist compact">
1797 <colgroup>
1798 <col align="left" valign="top">
1799 <col>
1800 </colgroup>
1801 <tbody>
1802 <tr>
1803 <td><p><span class="term">Parameters:</span></p></td>
1804 <td><div class="variablelist"><table border="0" class="variablelist compact">
1805 <colgroup>
1806 <col align="left" valign="top">
1807 <col>
1808 </colgroup>
1809 <tbody><tr>
1810 <td><p><span class="term"><code class="computeroutput">i</code></span></p></td>
1811 <td><p>The element's index.</p></td>
1812 </tr></tbody>
1813 </table></div></td>
1814 </tr>
1815 <tr>
1816 <td><p><span class="term">Requires:</span></p></td>
1817 <td><p><code class="computeroutput">i =&lt; size()</code></p></td>
1818 </tr>
1819 <tr>
1820 <td><p><span class="term">Returns:</span></p></td>
1821 <td><p>a iterator to the i-th element.</p></td>
1822 </tr>
1823 </tbody>
1824 </table></div>
1825 </li>
1826 <li class="listitem">
1827 <pre class="literallayout"><span class="identifier">const_iterator</span> <a name="idm45666066987136-bb"></a><span class="identifier">nth</span><span class="special">(</span><span class="identifier">size_type</span> i<span class="special">)</span> <span class="keyword">const</span><span class="special">;</span></pre>Returns a const_iterator to the i-th element. <p>
1828
1829
1830 </p>
1831 <p><b>Throws.&#160;</b>Nothing by default.</p>
1832 <p>
1833 </p>
1834 <p><b>Complexity.&#160;</b>Constant O(1). </p>
1835 <p>
1836 </p>
1837 <div class="variablelist"><table border="0" class="variablelist compact">
1838 <colgroup>
1839 <col align="left" valign="top">
1840 <col>
1841 </colgroup>
1842 <tbody>
1843 <tr>
1844 <td><p><span class="term">Parameters:</span></p></td>
1845 <td><div class="variablelist"><table border="0" class="variablelist compact">
1846 <colgroup>
1847 <col align="left" valign="top">
1848 <col>
1849 </colgroup>
1850 <tbody><tr>
1851 <td><p><span class="term"><code class="computeroutput">i</code></span></p></td>
1852 <td><p>The element's index.</p></td>
1853 </tr></tbody>
1854 </table></div></td>
1855 </tr>
1856 <tr>
1857 <td><p><span class="term">Requires:</span></p></td>
1858 <td><p><code class="computeroutput">i =&lt; size()</code></p></td>
1859 </tr>
1860 <tr>
1861 <td><p><span class="term">Returns:</span></p></td>
1862 <td><p>a const_iterator to the i-th element.</p></td>
1863 </tr>
1864 </tbody>
1865 </table></div>
1866 </li>
1867 <li class="listitem">
1868 <pre class="literallayout"><span class="identifier">size_type</span> <a name="idm45666066980832-bb"></a><span class="identifier">index_of</span><span class="special">(</span><span class="identifier">iterator</span> p<span class="special">)</span><span class="special">;</span></pre>Returns the index of the element pointed by p. <p>
1869
1870
1871 </p>
1872 <p><b>Throws.&#160;</b>Nothing by default.</p>
1873 <p>
1874 </p>
1875 <p><b>Complexity.&#160;</b>Constant O(1). </p>
1876 <p>
1877 </p>
1878 <div class="variablelist"><table border="0" class="variablelist compact">
1879 <colgroup>
1880 <col align="left" valign="top">
1881 <col>
1882 </colgroup>
1883 <tbody>
1884 <tr>
1885 <td><p><span class="term">Parameters:</span></p></td>
1886 <td><div class="variablelist"><table border="0" class="variablelist compact">
1887 <colgroup>
1888 <col align="left" valign="top">
1889 <col>
1890 </colgroup>
1891 <tbody><tr>
1892 <td><p><span class="term"><code class="computeroutput">p</code></span></p></td>
1893 <td><p>An iterator to the element.</p></td>
1894 </tr></tbody>
1895 </table></div></td>
1896 </tr>
1897 <tr>
1898 <td><p><span class="term">Requires:</span></p></td>
1899 <td><p><code class="computeroutput">begin() &lt;= p &lt;= end()</code></p></td>
1900 </tr>
1901 <tr>
1902 <td><p><span class="term">Returns:</span></p></td>
1903 <td><p>The index of the element pointed by p.</p></td>
1904 </tr>
1905 </tbody>
1906 </table></div>
1907 </li>
1908 <li class="listitem">
1909 <pre class="literallayout"><span class="identifier">size_type</span> <a name="idm45666066974784-bb"></a><span class="identifier">index_of</span><span class="special">(</span><span class="identifier">const_iterator</span> p<span class="special">)</span> <span class="keyword">const</span><span class="special">;</span></pre>Returns the index of the element pointed by p. <p>
1910
1911
1912 </p>
1913 <p><b>Throws.&#160;</b>Nothing by default.</p>
1914 <p>
1915 </p>
1916 <p><b>Complexity.&#160;</b>Constant O(1). </p>
1917 <p>
1918 </p>
1919 <div class="variablelist"><table border="0" class="variablelist compact">
1920 <colgroup>
1921 <col align="left" valign="top">
1922 <col>
1923 </colgroup>
1924 <tbody>
1925 <tr>
1926 <td><p><span class="term">Parameters:</span></p></td>
1927 <td><div class="variablelist"><table border="0" class="variablelist compact">
1928 <colgroup>
1929 <col align="left" valign="top">
1930 <col>
1931 </colgroup>
1932 <tbody><tr>
1933 <td><p><span class="term"><code class="computeroutput">p</code></span></p></td>
1934 <td><p>A const_iterator to the element.</p></td>
1935 </tr></tbody>
1936 </table></div></td>
1937 </tr>
1938 <tr>
1939 <td><p><span class="term">Requires:</span></p></td>
1940 <td><p><code class="computeroutput">begin() &lt;= p &lt;= end()</code></p></td>
1941 </tr>
1942 <tr>
1943 <td><p><span class="term">Returns:</span></p></td>
1944 <td><p>a const_iterator to the i-th element.</p></td>
1945 </tr>
1946 </tbody>
1947 </table></div>
1948 </li>
1949 <li class="listitem">
1950 <pre class="literallayout"><span class="identifier">reference</span> <a name="idm45666066968464-bb"></a><span class="identifier">front</span><span class="special">(</span><span class="special">)</span><span class="special">;</span></pre>Returns reference to the first element. <p>
1951
1952 </p>
1953 <p><b>Throws.&#160;</b>Nothing by default.</p>
1954 <p>
1955 </p>
1956 <p><b>Complexity.&#160;</b>Constant O(1). </p>
1957 <p>
1958 </p>
1959 <div class="variablelist"><table border="0" class="variablelist compact">
1960 <colgroup>
1961 <col align="left" valign="top">
1962 <col>
1963 </colgroup>
1964 <tbody>
1965 <tr>
1966 <td><p><span class="term">Requires:</span></p></td>
1967 <td><p><code class="computeroutput">!empty</code>()</p></td>
1968 </tr>
1969 <tr>
1970 <td><p><span class="term">Returns:</span></p></td>
1971 <td><p>reference to the first element from the beginning of the container.</p></td>
1972 </tr>
1973 </tbody>
1974 </table></div>
1975 </li>
1976 <li class="listitem">
1977 <pre class="literallayout"><span class="identifier">const_reference</span> <a name="idm45666066963344-bb"></a><span class="identifier">front</span><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span></pre>Returns const reference to the first element. <p>
1978
1979 </p>
1980 <p><b>Throws.&#160;</b>Nothing by default.</p>
1981 <p>
1982 </p>
1983 <p><b>Complexity.&#160;</b>Constant O(1). </p>
1984 <p>
1985 </p>
1986 <div class="variablelist"><table border="0" class="variablelist compact">
1987 <colgroup>
1988 <col align="left" valign="top">
1989 <col>
1990 </colgroup>
1991 <tbody>
1992 <tr>
1993 <td><p><span class="term">Requires:</span></p></td>
1994 <td><p><code class="computeroutput">!empty</code>()</p></td>
1995 </tr>
1996 <tr>
1997 <td><p><span class="term">Returns:</span></p></td>
1998 <td><p>const reference to the first element from the beginning of the container.</p></td>
1999 </tr>
2000 </tbody>
2001 </table></div>
2002 </li>
2003 <li class="listitem">
2004 <pre class="literallayout"><span class="identifier">reference</span> <a name="idm45666066957936-bb"></a><span class="identifier">back</span><span class="special">(</span><span class="special">)</span><span class="special">;</span></pre>Returns reference to the last element. <p>
2005
2006 </p>
2007 <p><b>Throws.&#160;</b>Nothing by default.</p>
2008 <p>
2009 </p>
2010 <p><b>Complexity.&#160;</b>Constant O(1). </p>
2011 <p>
2012 </p>
2013 <div class="variablelist"><table border="0" class="variablelist compact">
2014 <colgroup>
2015 <col align="left" valign="top">
2016 <col>
2017 </colgroup>
2018 <tbody>
2019 <tr>
2020 <td><p><span class="term">Requires:</span></p></td>
2021 <td><p><code class="computeroutput">!empty</code>()</p></td>
2022 </tr>
2023 <tr>
2024 <td><p><span class="term">Returns:</span></p></td>
2025 <td><p>reference to the last element from the beginning of the container.</p></td>
2026 </tr>
2027 </tbody>
2028 </table></div>
2029 </li>
2030 <li class="listitem">
2031 <pre class="literallayout"><span class="identifier">const_reference</span> <a name="idm45666066952832-bb"></a><span class="identifier">back</span><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span></pre>Returns const reference to the first element. <p>
2032
2033 </p>
2034 <p><b>Throws.&#160;</b>Nothing by default.</p>
2035 <p>
2036 </p>
2037 <p><b>Complexity.&#160;</b>Constant O(1). </p>
2038 <p>
2039 </p>
2040 <div class="variablelist"><table border="0" class="variablelist compact">
2041 <colgroup>
2042 <col align="left" valign="top">
2043 <col>
2044 </colgroup>
2045 <tbody>
2046 <tr>
2047 <td><p><span class="term">Requires:</span></p></td>
2048 <td><p><code class="computeroutput">!empty</code>()</p></td>
2049 </tr>
2050 <tr>
2051 <td><p><span class="term">Returns:</span></p></td>
2052 <td><p>const reference to the last element from the beginning of the container.</p></td>
2053 </tr>
2054 </tbody>
2055 </table></div>
2056 </li>
2057 <li class="listitem">
2058 <pre class="literallayout"><span class="identifier">T</span> <span class="special">*</span> <a name="idm45666066947424-bb"></a><span class="identifier">data</span><span class="special">(</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span></pre>Pointer such that <code class="computeroutput">[data(), data() + size())</code> is a valid range. For a non-empty vector <code class="computeroutput">data() == &amp;front()</code>. <p><b>Throws.&#160;</b>Nothing.</p>
2059 <p>
2060 </p>
2061 <p><b>Complexity.&#160;</b>Constant O(1). </p>
2062 <p>
2063 </p>
2064 </li>
2065 <li class="listitem">
2066 <pre class="literallayout"><span class="keyword">const</span> <span class="identifier">T</span> <span class="special">*</span> <a name="idm45666066942768-bb"></a><span class="identifier">data</span><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span></pre>Const pointer such that <code class="computeroutput">[data(), data() + size())</code> is a valid range. For a non-empty vector <code class="computeroutput">data() == &amp;front()</code>. <p><b>Throws.&#160;</b>Nothing.</p>
2067 <p>
2068 </p>
2069 <p><b>Complexity.&#160;</b>Constant O(1). </p>
2070 <p>
2071 </p>
2072 </li>
2073 <li class="listitem">
2074 <pre class="literallayout"><span class="identifier">iterator</span> <a name="idm45666066938096-bb"></a><span class="identifier">begin</span><span class="special">(</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span></pre>Returns iterator to the first element. <p>
2075 </p>
2076 <p><b>Throws.&#160;</b>Nothing.</p>
2077 <p>
2078 </p>
2079 <p><b>Complexity.&#160;</b>Constant O(1). </p>
2080 <p>
2081 </p>
2082 <div class="variablelist"><table border="0" class="variablelist compact">
2083 <colgroup>
2084 <col align="left" valign="top">
2085 <col>
2086 </colgroup>
2087 <tbody><tr>
2088 <td><p><span class="term">Returns:</span></p></td>
2089 <td><p>iterator to the first element contained in the vector.</p></td>
2090 </tr></tbody>
2091 </table></div>
2092 </li>
2093 <li class="listitem">
2094 <pre class="literallayout"><span class="identifier">const_iterator</span> <a name="idm45666066933600-bb"></a><span class="identifier">begin</span><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span></pre>Returns const iterator to the first element. <p>
2095 </p>
2096 <p><b>Throws.&#160;</b>Nothing.</p>
2097 <p>
2098 </p>
2099 <p><b>Complexity.&#160;</b>Constant O(1). </p>
2100 <p>
2101 </p>
2102 <div class="variablelist"><table border="0" class="variablelist compact">
2103 <colgroup>
2104 <col align="left" valign="top">
2105 <col>
2106 </colgroup>
2107 <tbody><tr>
2108 <td><p><span class="term">Returns:</span></p></td>
2109 <td><p>const_iterator to the first element contained in the vector.</p></td>
2110 </tr></tbody>
2111 </table></div>
2112 </li>
2113 <li class="listitem">
2114 <pre class="literallayout"><span class="identifier">const_iterator</span> <a name="idm45666066929072-bb"></a><span class="identifier">cbegin</span><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span></pre>Returns const iterator to the first element. <p>
2115 </p>
2116 <p><b>Throws.&#160;</b>Nothing.</p>
2117 <p>
2118 </p>
2119 <p><b>Complexity.&#160;</b>Constant O(1). </p>
2120 <p>
2121 </p>
2122 <div class="variablelist"><table border="0" class="variablelist compact">
2123 <colgroup>
2124 <col align="left" valign="top">
2125 <col>
2126 </colgroup>
2127 <tbody><tr>
2128 <td><p><span class="term">Returns:</span></p></td>
2129 <td><p>const_iterator to the first element contained in the vector.</p></td>
2130 </tr></tbody>
2131 </table></div>
2132 </li>
2133 <li class="listitem">
2134 <pre class="literallayout"><span class="identifier">iterator</span> <a name="idm45666066924544-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>Returns iterator to the one after the last element. <p>
2135 </p>
2136 <p><b>Throws.&#160;</b>Nothing.</p>
2137 <p>
2138 </p>
2139 <p><b>Complexity.&#160;</b>Constant O(1). </p>
2140 <p>
2141 </p>
2142 <div class="variablelist"><table border="0" class="variablelist compact">
2143 <colgroup>
2144 <col align="left" valign="top">
2145 <col>
2146 </colgroup>
2147 <tbody><tr>
2148 <td><p><span class="term">Returns:</span></p></td>
2149 <td><p>iterator pointing to the one after the last element contained in the vector.</p></td>
2150 </tr></tbody>
2151 </table></div>
2152 </li>
2153 <li class="listitem">
2154 <pre class="literallayout"><span class="identifier">const_iterator</span> <a name="idm45666066920000-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>Returns const iterator to the one after the last element. <p>
2155 </p>
2156 <p><b>Throws.&#160;</b>Nothing.</p>
2157 <p>
2158 </p>
2159 <p><b>Complexity.&#160;</b>Constant O(1). </p>
2160 <p>
2161 </p>
2162 <div class="variablelist"><table border="0" class="variablelist compact">
2163 <colgroup>
2164 <col align="left" valign="top">
2165 <col>
2166 </colgroup>
2167 <tbody><tr>
2168 <td><p><span class="term">Returns:</span></p></td>
2169 <td><p>const_iterator pointing to the one after the last element contained in the vector.</p></td>
2170 </tr></tbody>
2171 </table></div>
2172 </li>
2173 <li class="listitem">
2174 <pre class="literallayout"><span class="identifier">const_iterator</span> <a name="idm45666066915440-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>Returns const iterator to the one after the last element. <p>
2175 </p>
2176 <p><b>Throws.&#160;</b>Nothing.</p>
2177 <p>
2178 </p>
2179 <p><b>Complexity.&#160;</b>Constant O(1). </p>
2180 <p>
2181 </p>
2182 <div class="variablelist"><table border="0" class="variablelist compact">
2183 <colgroup>
2184 <col align="left" valign="top">
2185 <col>
2186 </colgroup>
2187 <tbody><tr>
2188 <td><p><span class="term">Returns:</span></p></td>
2189 <td><p>const_iterator pointing to the one after the last element contained in the vector.</p></td>
2190 </tr></tbody>
2191 </table></div>
2192 </li>
2193 <li class="listitem">
2194 <pre class="literallayout"><span class="identifier">reverse_iterator</span> <a name="idm45666066910880-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>Returns reverse iterator to the first element of the reversed container. <p>
2195 </p>
2196 <p><b>Throws.&#160;</b>Nothing.</p>
2197 <p>
2198 </p>
2199 <p><b>Complexity.&#160;</b>Constant O(1). </p>
2200 <p>
2201 </p>
2202 <div class="variablelist"><table border="0" class="variablelist compact">
2203 <colgroup>
2204 <col align="left" valign="top">
2205 <col>
2206 </colgroup>
2207 <tbody><tr>
2208 <td><p><span class="term">Returns:</span></p></td>
2209 <td><p>reverse_iterator pointing to the beginning of the reversed <a class="link" href="static_vector.html" title="Class template static_vector">static_vector</a>.</p></td>
2210 </tr></tbody>
2211 </table></div>
2212 </li>
2213 <li class="listitem">
2214 <pre class="literallayout"><span class="identifier">const_reverse_iterator</span> <a name="idm45666066905584-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>Returns const reverse iterator to the first element of the reversed container. <p>
2215 </p>
2216 <p><b>Throws.&#160;</b>Nothing.</p>
2217 <p>
2218 </p>
2219 <p><b>Complexity.&#160;</b>Constant O(1). </p>
2220 <p>
2221 </p>
2222 <div class="variablelist"><table border="0" class="variablelist compact">
2223 <colgroup>
2224 <col align="left" valign="top">
2225 <col>
2226 </colgroup>
2227 <tbody><tr>
2228 <td><p><span class="term">Returns:</span></p></td>
2229 <td><p>const_reverse_iterator pointing to the beginning of the reversed <a class="link" href="static_vector.html" title="Class template static_vector">static_vector</a>.</p></td>
2230 </tr></tbody>
2231 </table></div>
2232 </li>
2233 <li class="listitem">
2234 <pre class="literallayout"><span class="identifier">const_reverse_iterator</span> <a name="idm45666066900288-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>Returns const reverse iterator to the first element of the reversed container. <p>
2235 </p>
2236 <p><b>Throws.&#160;</b>Nothing.</p>
2237 <p>
2238 </p>
2239 <p><b>Complexity.&#160;</b>Constant O(1). </p>
2240 <p>
2241 </p>
2242 <div class="variablelist"><table border="0" class="variablelist compact">
2243 <colgroup>
2244 <col align="left" valign="top">
2245 <col>
2246 </colgroup>
2247 <tbody><tr>
2248 <td><p><span class="term">Returns:</span></p></td>
2249 <td><p>const_reverse_iterator pointing to the beginning of the reversed <a class="link" href="static_vector.html" title="Class template static_vector">static_vector</a>.</p></td>
2250 </tr></tbody>
2251 </table></div>
2252 </li>
2253 <li class="listitem">
2254 <pre class="literallayout"><span class="identifier">reverse_iterator</span> <a name="idm45666066894992-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>Returns reverse iterator to the one after the last element of the reversed container. <p>
2255 </p>
2256 <p><b>Throws.&#160;</b>Nothing.</p>
2257 <p>
2258 </p>
2259 <p><b>Complexity.&#160;</b>Constant O(1). </p>
2260 <p>
2261 </p>
2262 <div class="variablelist"><table border="0" class="variablelist compact">
2263 <colgroup>
2264 <col align="left" valign="top">
2265 <col>
2266 </colgroup>
2267 <tbody><tr>
2268 <td><p><span class="term">Returns:</span></p></td>
2269 <td><p>reverse_iterator pointing to the one after the last element of the reversed <a class="link" href="static_vector.html" title="Class template static_vector">static_vector</a>.</p></td>
2270 </tr></tbody>
2271 </table></div>
2272 </li>
2273 <li class="listitem">
2274 <pre class="literallayout"><span class="identifier">const_reverse_iterator</span> <a name="idm45666066889680-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>Returns const reverse iterator to the one after the last element of the reversed container. <p>
2275 </p>
2276 <p><b>Throws.&#160;</b>Nothing.</p>
2277 <p>
2278 </p>
2279 <p><b>Complexity.&#160;</b>Constant O(1). </p>
2280 <p>
2281 </p>
2282 <div class="variablelist"><table border="0" class="variablelist compact">
2283 <colgroup>
2284 <col align="left" valign="top">
2285 <col>
2286 </colgroup>
2287 <tbody><tr>
2288 <td><p><span class="term">Returns:</span></p></td>
2289 <td><p>const_reverse_iterator pointing to the one after the last element of the reversed <a class="link" href="static_vector.html" title="Class template static_vector">static_vector</a>.</p></td>
2290 </tr></tbody>
2291 </table></div>
2292 </li>
2293 <li class="listitem">
2294 <pre class="literallayout"><span class="identifier">const_reverse_iterator</span> <a name="idm45666066884352-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>Returns const reverse iterator to the one after the last element of the reversed container. <p>
2295 </p>
2296 <p><b>Throws.&#160;</b>Nothing.</p>
2297 <p>
2298 </p>
2299 <p><b>Complexity.&#160;</b>Constant O(1). </p>
2300 <p>
2301 </p>
2302 <div class="variablelist"><table border="0" class="variablelist compact">
2303 <colgroup>
2304 <col align="left" valign="top">
2305 <col>
2306 </colgroup>
2307 <tbody><tr>
2308 <td><p><span class="term">Returns:</span></p></td>
2309 <td><p>const_reverse_iterator pointing to the one after the last element of the reversed <a class="link" href="static_vector.html" title="Class template static_vector">static_vector</a>.</p></td>
2310 </tr></tbody>
2311 </table></div>
2312 </li>
2313 <li class="listitem">
2314 <pre class="literallayout"><span class="identifier">size_type</span> <a name="idm45666066879024-bb"></a><span class="identifier">size</span><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span></pre>Returns the number of stored elements. <p>
2315 </p>
2316 <p><b>Throws.&#160;</b>Nothing.</p>
2317 <p>
2318 </p>
2319 <p><b>Complexity.&#160;</b>Constant O(1). </p>
2320 <p>
2321 </p>
2322 <div class="variablelist"><table border="0" class="variablelist compact">
2323 <colgroup>
2324 <col align="left" valign="top">
2325 <col>
2326 </colgroup>
2327 <tbody><tr>
2328 <td><p><span class="term">Returns:</span></p></td>
2329 <td><p>Number of elements contained in the container.</p></td>
2330 </tr></tbody>
2331 </table></div>
2332 </li>
2333 <li class="listitem">
2334 <pre class="literallayout"><span class="keyword">bool</span> <a name="idm45666066874528-bb"></a><span class="identifier">empty</span><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span></pre>Queries if the container contains elements. <p>
2335 </p>
2336 <p><b>Throws.&#160;</b>Nothing.</p>
2337 <p>
2338 </p>
2339 <p><b>Complexity.&#160;</b>Constant O(1). </p>
2340 <p>
2341 </p>
2342 <div class="variablelist"><table border="0" class="variablelist compact">
2343 <colgroup>
2344 <col align="left" valign="top">
2345 <col>
2346 </colgroup>
2347 <tbody><tr>
2348 <td><p><span class="term">Returns:</span></p></td>
2349 <td><p>true if the number of elements contained in the container is equal to 0.</p></td>
2350 </tr></tbody>
2351 </table></div>
2352 </li>
2353 </ol></div>
2354 </div>
2355 <div class="refsect2">
2356 <a name="id-1.3.10.14.38.3.4.9"></a><h3>
2357 <a name="idm45666066739360-bb"></a><code class="computeroutput">static_vector</code> public static functions</h3>
2358 <div class="orderedlist"><ol class="orderedlist" type="1">
2359 <li class="listitem">
2360 <pre class="literallayout"><span class="keyword">static</span> <span class="identifier">size_type</span> <a name="idm45666066738800-bb"></a><span class="identifier">capacity</span><span class="special">(</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span></pre>Returns container's capacity. <p>
2361 </p>
2362 <p><b>Throws.&#160;</b>Nothing.</p>
2363 <p>
2364 </p>
2365 <p><b>Complexity.&#160;</b>Constant O(1). </p>
2366 <p>
2367 </p>
2368 <div class="variablelist"><table border="0" class="variablelist compact">
2369 <colgroup>
2370 <col align="left" valign="top">
2371 <col>
2372 </colgroup>
2373 <tbody><tr>
2374 <td><p><span class="term">Returns:</span></p></td>
2375 <td><p>container's capacity.</p></td>
2376 </tr></tbody>
2377 </table></div>
2378 </li>
2379 <li class="listitem">
2380 <pre class="literallayout"><span class="keyword">static</span> <span class="identifier">size_type</span> <a name="idm45666066734064-bb"></a><span class="identifier">max_size</span><span class="special">(</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span></pre>Returns container's capacity. <p>
2381 </p>
2382 <p><b>Throws.&#160;</b>Nothing.</p>
2383 <p>
2384 </p>
2385 <p><b>Complexity.&#160;</b>Constant O(1). </p>
2386 <p>
2387 </p>
2388 <div class="variablelist"><table border="0" class="variablelist compact">
2389 <colgroup>
2390 <col align="left" valign="top">
2391 <col>
2392 </colgroup>
2393 <tbody><tr>
2394 <td><p><span class="term">Returns:</span></p></td>
2395 <td><p>container's capacity.</p></td>
2396 </tr></tbody>
2397 </table></div>
2398 </li>
2399 </ol></div>
2400 </div>
2401 </div>
2402 </div>
2403 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
2404 <td align="left"></td>
2405 <td align="right"><div class="copyright-footer">Copyright &#169; 2009-2018 Ion Gaztanaga<p>
2406         Distributed under the Boost Software License, Version 1.0. (See accompanying
2407         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>)
2408       </p>
2409 </div></td>
2410 </tr></table>
2411 <hr>
2412 <div class="spirit-nav">
2413 <a accesskey="p" href="pmr/stable_vector_of.html"><img src="../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../../boost_container_header_reference.html#header.boost.container.static_vector_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="operator_idm45666066728976.html"><img src="../../../../doc/src/images/next.png" alt="Next"></a>
2414 </div>
2415 </body>
2416 </html>