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 circular_buffer_space_optimized</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_circular_buffer_c___reference.html#header.boost.circular_buffer.space_optimized_hpp" title="Header <boost/circular_buffer/space_optimized.hpp>"> 10<link rel="prev" href="swap_idm46495624055088.html" title="Function template swap"> 11<link rel="next" href="../circular_buffer/s14.html" title="Index"> 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="swap_idm46495624055088.html"><img src="../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../boost_circular_buffer_c___reference.html#header.boost.circular_buffer.space_optimized_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="../circular_buffer/s14.html"><img src="../../../doc/src/images/next.png" alt="Next"></a> 25</div> 26<div class="refentry"> 27<a name="boost.circular_idm46495624036048"></a><div class="titlepage"></div> 28<div class="refnamediv"> 29<h2><span class="refentrytitle">Class template circular_buffer_space_optimized</span></h2> 30<p>boost::circular_buffer_space_optimized — Space optimized circular buffer container adaptor. <code class="computeroutput">T</code> must be a copyable class or must have an noexcept move constructor and move assignment operator. </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: <<a class="link" href="../boost_circular_buffer_c___reference.html#header.boost.circular_buffer.space_optimized_hpp" title="Header <boost/circular_buffer/space_optimized.hpp>">boost/circular_buffer/space_optimized.hpp</a>> 34 35</span><span class="keyword">template</span><span class="special"><</span><span class="keyword">typename</span> T<span class="special">,</span> <span class="keyword">typename</span> Alloc<span class="special">></span> 36<span class="keyword">class</span> <a class="link" href="circular_idm46495624036048.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a> <span class="special">:</span> 37 <span class="keyword">private</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">circular_buffer</span><span class="special"><</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">Alloc</span> <span class="special">></span> 38<span class="special">{</span> 39<span class="keyword">public</span><span class="special">:</span> 40 <span class="comment">// <a class="link" href="circular_idm46495624036048.html#boost.circular_idm46495624036048types">types</a></span> 41 <span class="keyword">typedef</span> <a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a><span class="special"><</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">Alloc</span> <span class="special">></span><span class="special">::</span><span class="identifier">value_type</span> <a name="boost.circular_idm46495624036048.value_type"></a><span class="identifier">value_type</span><span class="special">;</span> 42 <span class="keyword">typedef</span> <a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a><span class="special"><</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">Alloc</span> <span class="special">></span><span class="special">::</span><span class="identifier">pointer</span> <a name="boost.circular_idm46495624036048.pointer"></a><span class="identifier">pointer</span><span class="special">;</span> 43 <span class="keyword">typedef</span> <a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a><span class="special"><</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">Alloc</span> <span class="special">></span><span class="special">::</span><span class="identifier">const_pointer</span> <a name="boost.circular_idm46495624036048.const_pointer"></a><span class="identifier">const_pointer</span><span class="special">;</span> 44 <span class="keyword">typedef</span> <a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a><span class="special"><</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">Alloc</span> <span class="special">></span><span class="special">::</span><span class="identifier">reference</span> <a name="boost.circular_idm46495624036048.reference"></a><span class="identifier">reference</span><span class="special">;</span> 45 <span class="keyword">typedef</span> <a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a><span class="special"><</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">Alloc</span> <span class="special">></span><span class="special">::</span><span class="identifier">const_reference</span> <a name="boost.circular_idm46495624036048.const_reference"></a><span class="identifier">const_reference</span><span class="special">;</span> 46 <span class="keyword">typedef</span> <a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a><span class="special"><</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">Alloc</span> <span class="special">></span><span class="special">::</span><span class="identifier">size_type</span> <a name="boost.circular_idm46495624036048.size_type"></a><span class="identifier">size_type</span><span class="special">;</span> 47 <span class="keyword">typedef</span> <a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a><span class="special"><</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">Alloc</span> <span class="special">></span><span class="special">::</span><span class="identifier">difference_type</span> <a name="boost.circular_idm46495624036048.difference_type"></a><span class="identifier">difference_type</span><span class="special">;</span> 48 <span class="keyword">typedef</span> <a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a><span class="special"><</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">Alloc</span> <span class="special">></span><span class="special">::</span><span class="identifier">allocator_type</span> <a name="boost.circular_idm46495624036048.allocator_type"></a><span class="identifier">allocator_type</span><span class="special">;</span> 49 <span class="keyword">typedef</span> <a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a><span class="special"><</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">Alloc</span> <span class="special">></span><span class="special">::</span><span class="identifier">const_iterator</span> <a name="boost.circular_idm46495624036048.const_iterator"></a><span class="identifier">const_iterator</span><span class="special">;</span> 50 <span class="keyword">typedef</span> <a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a><span class="special"><</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">Alloc</span> <span class="special">></span><span class="special">::</span><span class="identifier">iterator</span> <a name="boost.circular_idm46495624036048.iterator"></a><span class="identifier">iterator</span><span class="special">;</span> 51 <span class="keyword">typedef</span> <a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a><span class="special"><</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">Alloc</span> <span class="special">></span><span class="special">::</span><span class="identifier">const_reverse_iterator</span> <a name="boost.circular_idm46495624036048.const_reverse_iterator"></a><span class="identifier">const_reverse_iterator</span><span class="special">;</span> 52 <span class="keyword">typedef</span> <a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a><span class="special"><</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">Alloc</span> <span class="special">></span><span class="special">::</span><span class="identifier">reverse_iterator</span> <a name="boost.circular_idm46495624036048.reverse_iterator"></a><span class="identifier">reverse_iterator</span><span class="special">;</span> 53 <span class="keyword">typedef</span> <a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a><span class="special"><</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">Alloc</span> <span class="special">></span><span class="special">::</span><span class="identifier">array_range</span> <a name="boost.circular_idm46495624036048.array_range"></a><span class="identifier">array_range</span><span class="special">;</span> 54 <span class="keyword">typedef</span> <a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a><span class="special"><</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">Alloc</span> <span class="special">></span><span class="special">::</span><span class="identifier">const_array_range</span> <a name="boost.circular_idm46495624036048.const_array_range"></a><span class="identifier">const_array_range</span><span class="special">;</span> 55 <span class="keyword">typedef</span> <a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a><span class="special"><</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">Alloc</span> <span class="special">></span><span class="special">::</span><span class="identifier">param_value_type</span> <a name="boost.circular_idm46495624036048.param_value_type"></a><span class="identifier">param_value_type</span><span class="special">;</span> 56 <span class="keyword">typedef</span> <a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a><span class="special"><</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">Alloc</span> <span class="special">></span><span class="special">::</span><span class="identifier">rvalue_type</span> <a name="boost.circular_idm46495624036048.rvalue_type"></a><span class="identifier">rvalue_type</span><span class="special">;</span> 57 <span class="keyword">typedef</span> <span class="identifier">cb_details</span><span class="special">::</span><span class="identifier">capacity_control</span><span class="special"><</span> <span class="identifier">size_type</span> <span class="special">></span> <a class="link" href="circular_idm46495624036048.html#boost.circular_idm46495624036048.capacity_type"><span class="identifier">capacity_type</span></a><span class="special">;</span> 58 59 <span class="comment">// <a class="link" href="circular_idm46495624036048.html#boost.circular_idm46495624036048construct-copy-destruct">construct/copy/destruct</a></span> 60 <span class="keyword">explicit</span> <a class="link" href="circular_idm46495624036048.html#idm46495623268224-bb"><span class="identifier">circular_buffer_space_optimized</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">allocator_type</span> <span class="special">&</span> <span class="special">=</span> <span class="identifier">allocator_type</span><span class="special">(</span><span class="special">)</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span> 61 <span class="keyword">explicit</span> <a class="link" href="circular_idm46495624036048.html#idm46495623261728-bb"><span class="identifier">circular_buffer_space_optimized</span></a><span class="special">(</span><span class="identifier">capacity_type</span><span class="special">,</span> 62 <span class="keyword">const</span> <span class="identifier">allocator_type</span> <span class="special">&</span> <span class="special">=</span> <span class="identifier">allocator_type</span><span class="special">(</span><span class="special">)</span><span class="special">)</span><span class="special">;</span> 63 <a class="link" href="circular_idm46495624036048.html#idm46495623252864-bb"><span class="identifier">circular_buffer_space_optimized</span></a><span class="special">(</span><span class="identifier">capacity_type</span><span class="special">,</span> <span class="identifier">param_value_type</span><span class="special">,</span> 64 <span class="keyword">const</span> <span class="identifier">allocator_type</span> <span class="special">&</span> <span class="special">=</span> <span class="identifier">allocator_type</span><span class="special">(</span><span class="special">)</span><span class="special">)</span><span class="special">;</span> 65 <a class="link" href="circular_idm46495624036048.html#idm46495623240352-bb"><span class="identifier">circular_buffer_space_optimized</span></a><span class="special">(</span><span class="identifier">capacity_type</span><span class="special">,</span> <span class="identifier">size_type</span><span class="special">,</span> <span class="identifier">param_value_type</span><span class="special">,</span> 66 <span class="keyword">const</span> <span class="identifier">allocator_type</span> <span class="special">&</span> <span class="special">=</span> <span class="identifier">allocator_type</span><span class="special">(</span><span class="special">)</span><span class="special">)</span><span class="special">;</span> 67 <a class="link" href="circular_idm46495624036048.html#idm46495623225008-bb"><span class="identifier">circular_buffer_space_optimized</span></a><span class="special">(</span><span class="keyword">const</span> <a class="link" href="circular_idm46495624036048.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a><span class="special"><</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">Alloc</span> <span class="special">></span> <span class="special">&</span><span class="special">)</span><span class="special">;</span> 68 <a class="link" href="circular_idm46495624036048.html#idm46495623215776-bb"><span class="identifier">circular_buffer_space_optimized</span></a><span class="special">(</span><a class="link" href="circular_idm46495624036048.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a><span class="special"><</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">Alloc</span> <span class="special">></span> <span class="special">&&</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span> 69 <span class="keyword">template</span><span class="special"><</span><span class="keyword">typename</span> InputIterator<span class="special">></span> 70 <a class="link" href="circular_idm46495624036048.html#idm46495623207584-bb"><span class="identifier">circular_buffer_space_optimized</span></a><span class="special">(</span><span class="identifier">InputIterator</span><span class="special">,</span> <span class="identifier">InputIterator</span><span class="special">,</span> 71 <span class="keyword">const</span> <span class="identifier">allocator_type</span> <span class="special">&</span> <span class="special">=</span> <span class="identifier">allocator_type</span><span class="special">(</span><span class="special">)</span><span class="special">)</span><span class="special">;</span> 72 <span class="keyword">template</span><span class="special"><</span><span class="keyword">typename</span> InputIterator<span class="special">></span> 73 <a class="link" href="circular_idm46495624036048.html#idm46495623193040-bb"><span class="identifier">circular_buffer_space_optimized</span></a><span class="special">(</span><span class="identifier">capacity_type</span><span class="special">,</span> <span class="identifier">InputIterator</span><span class="special">,</span> 74 <span class="identifier">InputIterator</span><span class="special">,</span> 75 <span class="keyword">const</span> <span class="identifier">allocator_type</span> <span class="special">&</span> <span class="special">=</span> <span class="identifier">allocator_type</span><span class="special">(</span><span class="special">)</span><span class="special">)</span><span class="special">;</span> 76 <a class="link" href="circular_idm46495624036048.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a><span class="special"><</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">Alloc</span> <span class="special">></span> <span class="special">&</span> 77 <a class="link" href="circular_idm46495624036048.html#idm46495623173392-bb"><span class="keyword">operator</span><span class="special">=</span></a><span class="special">(</span><span class="keyword">const</span> <a class="link" href="circular_idm46495624036048.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a><span class="special"><</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">Alloc</span> <span class="special">></span> <span class="special">&</span><span class="special">)</span><span class="special">;</span> 78 <a class="link" href="circular_idm46495624036048.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a><span class="special"><</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">Alloc</span> <span class="special">></span> <span class="special">&</span> 79 <a class="link" href="circular_idm46495624036048.html#idm46495623156256-bb"><span class="keyword">operator</span><span class="special">=</span></a><span class="special">(</span><a class="link" href="circular_idm46495624036048.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a><span class="special"><</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">Alloc</span> <span class="special">></span> <span class="special">&&</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span> 80 81 <span class="comment">// <a class="link" href="circular_idm46495624036048.html#idm46495623999456-bb">public member functions</a></span> 82 <span class="keyword">bool</span> <a class="link" href="circular_idm46495624036048.html#idm46495623998896-bb"><span class="identifier">full</span></a><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span> 83 <span class="identifier">size_type</span> <a class="link" href="circular_idm46495624036048.html#idm46495623986800-bb"><span class="identifier">reserve</span></a><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span> 84 <span class="keyword">const</span> <span class="identifier">capacity_type</span> <span class="special">&</span> <a class="link" href="circular_idm46495624036048.html#idm46495623975968-bb"><span class="identifier">capacity</span></a><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span> 85 <span class="keyword">void</span> <a class="link" href="circular_idm46495624036048.html#idm46495623964032-bb"><span class="identifier">set_capacity</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">capacity_type</span> <span class="special">&</span><span class="special">)</span><span class="special">;</span> 86 <span class="keyword">void</span> <a class="link" href="circular_idm46495624036048.html#idm46495623940880-bb"><span class="identifier">resize</span></a><span class="special">(</span><span class="identifier">size_type</span><span class="special">,</span> <span class="identifier">param_value_type</span> <span class="special">=</span> <span class="identifier">value_type</span><span class="special">(</span><span class="special">)</span><span class="special">)</span><span class="special">;</span> 87 <span class="keyword">void</span> <a class="link" href="circular_idm46495624036048.html#idm46495623918144-bb"><span class="identifier">rset_capacity</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">capacity_type</span> <span class="special">&</span><span class="special">)</span><span class="special">;</span> 88 <span class="keyword">void</span> <a class="link" href="circular_idm46495624036048.html#idm46495623899392-bb"><span class="identifier">rresize</span></a><span class="special">(</span><span class="identifier">size_type</span><span class="special">,</span> <span class="identifier">param_value_type</span> <span class="special">=</span> <span class="identifier">value_type</span><span class="special">(</span><span class="special">)</span><span class="special">)</span><span class="special">;</span> 89 <span class="keyword">void</span> <a class="link" href="circular_idm46495624036048.html#idm46495623876656-bb"><span class="identifier">assign</span></a><span class="special">(</span><span class="identifier">size_type</span><span class="special">,</span> <span class="identifier">param_value_type</span><span class="special">)</span><span class="special">;</span> 90 <span class="keyword">void</span> <a class="link" href="circular_idm46495624036048.html#idm46495623857376-bb"><span class="identifier">assign</span></a><span class="special">(</span><span class="identifier">capacity_type</span><span class="special">,</span> <span class="identifier">size_type</span><span class="special">,</span> <span class="identifier">param_value_type</span><span class="special">)</span><span class="special">;</span> 91 <span class="keyword">template</span><span class="special"><</span><span class="keyword">typename</span> InputIterator<span class="special">></span> <span class="keyword">void</span> <a class="link" href="circular_idm46495624036048.html#idm46495623835184-bb"><span class="identifier">assign</span></a><span class="special">(</span><span class="identifier">InputIterator</span><span class="special">,</span> <span class="identifier">InputIterator</span><span class="special">)</span><span class="special">;</span> 92 <span class="keyword">template</span><span class="special"><</span><span class="keyword">typename</span> InputIterator<span class="special">></span> 93 <span class="keyword">void</span> <a class="link" href="circular_idm46495624036048.html#idm46495623814080-bb"><span class="identifier">assign</span></a><span class="special">(</span><span class="identifier">capacity_type</span><span class="special">,</span> <span class="identifier">InputIterator</span><span class="special">,</span> <span class="identifier">InputIterator</span><span class="special">)</span><span class="special">;</span> 94 <span class="keyword">void</span> <a class="link" href="circular_idm46495624036048.html#idm46495623787248-bb"><span class="identifier">swap</span></a><span class="special">(</span><a class="link" href="circular_idm46495624036048.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a><span class="special"><</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">Alloc</span> <span class="special">></span> <span class="special">&</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span> 95 <span class="keyword">void</span> <a class="link" href="circular_idm46495624036048.html#idm46495623772752-bb"><span class="identifier">push_back</span></a><span class="special">(</span><span class="identifier">param_value_type</span><span class="special">)</span><span class="special">;</span> 96 <span class="keyword">void</span> <a class="link" href="circular_idm46495624036048.html#idm46495623756880-bb"><span class="identifier">push_back</span></a><span class="special">(</span><span class="identifier">rvalue_type</span><span class="special">)</span><span class="special">;</span> 97 <span class="keyword">void</span> <a class="link" href="circular_idm46495624036048.html#idm46495623741472-bb"><span class="identifier">push_back</span></a><span class="special">(</span><span class="special">)</span><span class="special">;</span> 98 <span class="keyword">void</span> <a class="link" href="circular_idm46495624036048.html#idm46495623725824-bb"><span class="identifier">push_front</span></a><span class="special">(</span><span class="identifier">param_value_type</span><span class="special">)</span><span class="special">;</span> 99 <span class="keyword">void</span> <a class="link" href="circular_idm46495624036048.html#idm46495623709952-bb"><span class="identifier">push_front</span></a><span class="special">(</span><span class="identifier">rvalue_type</span><span class="special">)</span><span class="special">;</span> 100 <span class="keyword">void</span> <a class="link" href="circular_idm46495624036048.html#idm46495623693632-bb"><span class="identifier">push_front</span></a><span class="special">(</span><span class="special">)</span><span class="special">;</span> 101 <span class="keyword">void</span> <a class="link" href="circular_idm46495624036048.html#idm46495623677984-bb"><span class="identifier">pop_back</span></a><span class="special">(</span><span class="special">)</span><span class="special">;</span> 102 <span class="keyword">void</span> <a class="link" href="circular_idm46495624036048.html#idm46495623664368-bb"><span class="identifier">pop_front</span></a><span class="special">(</span><span class="special">)</span><span class="special">;</span> 103 <span class="identifier">iterator</span> <a class="link" href="circular_idm46495624036048.html#idm46495623650752-bb"><span class="identifier">insert</span></a><span class="special">(</span><span class="identifier">iterator</span><span class="special">,</span> <span class="identifier">param_value_type</span><span class="special">)</span><span class="special">;</span> 104 <span class="identifier">iterator</span> <a class="link" href="circular_idm46495624036048.html#idm46495623625728-bb"><span class="identifier">insert</span></a><span class="special">(</span><span class="identifier">iterator</span><span class="special">,</span> <span class="identifier">rvalue_type</span><span class="special">)</span><span class="special">;</span> 105 <span class="identifier">iterator</span> <a class="link" href="circular_idm46495624036048.html#idm46495623600720-bb"><span class="identifier">insert</span></a><span class="special">(</span><span class="identifier">iterator</span><span class="special">)</span><span class="special">;</span> 106 <span class="keyword">void</span> <a class="link" href="circular_idm46495624036048.html#idm46495623576384-bb"><span class="identifier">insert</span></a><span class="special">(</span><span class="identifier">iterator</span><span class="special">,</span> <span class="identifier">size_type</span><span class="special">,</span> <span class="identifier">param_value_type</span><span class="special">)</span><span class="special">;</span> 107 <span class="keyword">template</span><span class="special"><</span><span class="keyword">typename</span> InputIterator<span class="special">></span> 108 <span class="keyword">void</span> <a class="link" href="circular_idm46495624036048.html#idm46495623543824-bb"><span class="identifier">insert</span></a><span class="special">(</span><span class="identifier">iterator</span><span class="special">,</span> <span class="identifier">InputIterator</span><span class="special">,</span> <span class="identifier">InputIterator</span><span class="special">)</span><span class="special">;</span> 109 <span class="identifier">iterator</span> <a class="link" href="circular_idm46495624036048.html#idm46495623505200-bb"><span class="identifier">rinsert</span></a><span class="special">(</span><span class="identifier">iterator</span><span class="special">,</span> <span class="identifier">param_value_type</span><span class="special">)</span><span class="special">;</span> 110 <span class="identifier">iterator</span> <a class="link" href="circular_idm46495624036048.html#idm46495623480192-bb"><span class="identifier">rinsert</span></a><span class="special">(</span><span class="identifier">iterator</span><span class="special">,</span> <span class="identifier">rvalue_type</span><span class="special">)</span><span class="special">;</span> 111 <span class="identifier">iterator</span> <a class="link" href="circular_idm46495624036048.html#idm46495623455200-bb"><span class="identifier">rinsert</span></a><span class="special">(</span><span class="identifier">iterator</span><span class="special">)</span><span class="special">;</span> 112 <span class="keyword">void</span> <a class="link" href="circular_idm46495624036048.html#idm46495623430880-bb"><span class="identifier">rinsert</span></a><span class="special">(</span><span class="identifier">iterator</span><span class="special">,</span> <span class="identifier">size_type</span><span class="special">,</span> <span class="identifier">param_value_type</span><span class="special">)</span><span class="special">;</span> 113 <span class="keyword">template</span><span class="special"><</span><span class="keyword">typename</span> InputIterator<span class="special">></span> 114 <span class="keyword">void</span> <a class="link" href="circular_idm46495624036048.html#idm46495623398352-bb"><span class="identifier">rinsert</span></a><span class="special">(</span><span class="identifier">iterator</span><span class="special">,</span> <span class="identifier">InputIterator</span><span class="special">,</span> <span class="identifier">InputIterator</span><span class="special">)</span><span class="special">;</span> 115 <span class="identifier">iterator</span> <a class="link" href="circular_idm46495624036048.html#idm46495623359728-bb"><span class="identifier">erase</span></a><span class="special">(</span><span class="identifier">iterator</span><span class="special">)</span><span class="special">;</span> 116 <span class="identifier">iterator</span> <a class="link" href="circular_idm46495624036048.html#idm46495623341616-bb"><span class="identifier">erase</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> 117 <span class="identifier">iterator</span> <a class="link" href="circular_idm46495624036048.html#idm46495623322720-bb"><span class="identifier">rerase</span></a><span class="special">(</span><span class="identifier">iterator</span><span class="special">)</span><span class="special">;</span> 118 <span class="identifier">iterator</span> <a class="link" href="circular_idm46495624036048.html#idm46495623302480-bb"><span class="identifier">rerase</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> 119 <span class="keyword">void</span> <a class="link" href="circular_idm46495624036048.html#idm46495623281280-bb"><span class="identifier">clear</span></a><span class="special">(</span><span class="special">)</span><span class="special">;</span> 120<span class="special">}</span><span class="special">;</span></pre></div> 121<div class="refsect1"> 122<a name="id-1.3.9.16.4.3.4"></a><h2>Description</h2> 123<div class="refsect2"> 124<a name="id-1.3.9.16.4.3.4.2"></a><h3> 125<a name="boost.circular_idm46495624036048types"></a><code class="computeroutput">circular_buffer_space_optimized</code> 126 public 127 types</h3> 128<div class="orderedlist"><ol class="orderedlist" type="1"><li class="listitem"> 129<p> 130<span class="keyword">typedef</span> <span class="identifier">cb_details</span><span class="special">::</span><span class="identifier">capacity_control</span><span class="special"><</span> <span class="identifier">size_type</span> <span class="special">></span> <a name="boost.circular_idm46495624036048.capacity_type"></a><span class="identifier">capacity_type</span><span class="special">;</span></p> 131<p>Capacity controller of the space optimized circular buffer.</p> 132<p><span class="bold"><strong>See Also:</strong></span></p> 133<p>capacity_control in details.hpp. </p> 134<p> 135</p> 136<p> 137<code class="computeroutput"> class capacity_control<br> 138 {<br> 139 size_type m_capacity; // Available capacity.<br> 140 size_type m_min_capacity; // Minimum capacity.<br> 141 public:<br> 142 capacity_control(size_type capacity, size_type min_capacity = 0)<br> 143 : m_capacity(capacity), m_min_capacity(min_capacity)<br> 144 {};<br> 145 size_type capacity() const { return m_capacity; }<br> 146 size_type min_capacity() const { return m_min_capacity; }<br> 147 operator size_type() const { return m_capacity; }<br> 148 };<br> 149 </code> </p> 150<p>Always <code class="computeroutput">capacity >= min_capacity</code>. </p> 151<p>The <code class="computeroutput">capacity()</code> represents the capacity of the <code class="computeroutput"><a class="link" href="circular_idm46495624036048.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code> and the <code class="computeroutput">min_capacity()</code> determines the minimal allocated size of its internal buffer. </p> 152<p>The converting constructor of the <code class="computeroutput">capacity_control</code> allows implicit conversion from <code class="computeroutput">size_type</code>-like types which ensures compatibility of creating an instance of the <code class="computeroutput"><a class="link" href="circular_idm46495624036048.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code> with other STL containers.</p> 153<p>On the other hand the operator <code class="computeroutput">size_type()</code> provides implicit conversion to the <code class="computeroutput">size_type</code> which allows to treat the capacity of the <code class="computeroutput"><a class="link" href="circular_idm46495624036048.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code> the same way as in the <code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code>. </p> 154</li></ol></div> 155</div> 156<div class="refsect2"> 157<a name="id-1.3.9.16.4.3.4.3"></a><h3> 158<a name="boost.circular_idm46495624036048construct-copy-destruct"></a><code class="computeroutput">circular_buffer_space_optimized</code> 159 public 160 construct/copy/destruct</h3> 161<div class="orderedlist"><ol class="orderedlist" type="1"> 162<li class="listitem"> 163<pre class="literallayout"><span class="keyword">explicit</span> <a name="idm46495623268224-bb"></a><span class="identifier">circular_buffer_space_optimized</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">allocator_type</span> <span class="special">&</span> alloc <span class="special">=</span> <span class="identifier">allocator_type</span><span class="special">(</span><span class="special">)</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span></pre>Create an empty space optimized circular buffer with zero capacity. <p> 164 165 166</p> 167<p><b>Complexity. </b>Constant. </p> 168<p> 169</p> 170<div class="warning"><table border="0" summary="Warning"> 171<tr> 172<td rowspan="2" align="center" valign="top" width="25"><img alt="[Warning]" src="../../../doc/src/images/warning.png"></td> 173<th align="left">Warning</th> 174</tr> 175<tr><td align="left" valign="top"><p>Since Boost version 1.36 the behaviour of this constructor has changed. Now it creates a space optimized circular buffer with zero capacity. </p></td></tr> 176</table></div> 177<p> 178</p> 179<div class="variablelist"><table border="0" class="variablelist compact"> 180<colgroup> 181<col align="left" valign="top"> 182<col> 183</colgroup> 184<tbody> 185<tr> 186<td><p><span class="term">Parameters:</span></p></td> 187<td><div class="variablelist"><table border="0" class="variablelist compact"> 188<colgroup> 189<col align="left" valign="top"> 190<col> 191</colgroup> 192<tbody><tr> 193<td><p><span class="term"><code class="computeroutput">alloc</code></span></p></td> 194<td><p>The allocator. </p></td> 195</tr></tbody> 196</table></div></td> 197</tr> 198<tr> 199<td><p><span class="term">Postconditions:</span></p></td> 200<td><p><code class="computeroutput">capacity().capacity() == 0 && capacity().min_capacity() == 0 && size() == 0</code> </p></td> 201</tr> 202<tr> 203<td><p><span class="term">Throws:</span></p></td> 204<td>Nothing. </td> 205</tr> 206</tbody> 207</table></div> 208</li> 209<li class="listitem"> 210<pre class="literallayout"><span class="keyword">explicit</span> <a name="idm46495623261728-bb"></a><span class="identifier">circular_buffer_space_optimized</span><span class="special">(</span><span class="identifier">capacity_type</span> capacity_ctrl<span class="special">,</span> 211 <span class="keyword">const</span> <span class="identifier">allocator_type</span> <span class="special">&</span> alloc <span class="special">=</span> <span class="identifier">allocator_type</span><span class="special">(</span><span class="special">)</span><span class="special">)</span><span class="special">;</span></pre>Create an empty space optimized circular buffer with the specified capacity. <p> 212 213 214</p> 215<p><b>Complexity. </b>Constant. </p> 216<p> 217</p> 218<div class="variablelist"><table border="0" class="variablelist compact"> 219<colgroup> 220<col align="left" valign="top"> 221<col> 222</colgroup> 223<tbody> 224<tr> 225<td><p><span class="term">Parameters:</span></p></td> 226<td><div class="variablelist"><table border="0" class="variablelist compact"> 227<colgroup> 228<col align="left" valign="top"> 229<col> 230</colgroup> 231<tbody> 232<tr> 233<td><p><span class="term"><code class="computeroutput">alloc</code></span></p></td> 234<td><p>The allocator. </p></td> 235</tr> 236<tr> 237<td><p><span class="term"><code class="computeroutput">capacity_ctrl</code></span></p></td> 238<td><p>The capacity controller representing the maximum number of elements which can be stored in the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_idm46495624036048.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code> and the minimal allocated size of the internal buffer. </p></td> 239</tr> 240</tbody> 241</table></div></td> 242</tr> 243<tr> 244<td><p><span class="term">Postconditions:</span></p></td> 245<td><p><code class="computeroutput">capacity() == capacity_ctrl && size() == 0</code><br> 246<br> 247 The amount of allocated memory in the internal buffer is <code class="computeroutput">capacity_ctrl.min_capacity()</code>. </p></td> 248</tr> 249<tr> 250<td><p><span class="term">Throws:</span></p></td> 251<td>An allocation error if memory is exhausted (<code class="computeroutput">std::bad_alloc</code> if the standard allocator is used). </td> 252</tr> 253</tbody> 254</table></div> 255</li> 256<li class="listitem"> 257<pre class="literallayout"><a name="idm46495623252864-bb"></a><span class="identifier">circular_buffer_space_optimized</span><span class="special">(</span><span class="identifier">capacity_type</span> capacity_ctrl<span class="special">,</span> 258 <span class="identifier">param_value_type</span> item<span class="special">,</span> 259 <span class="keyword">const</span> <span class="identifier">allocator_type</span> <span class="special">&</span> alloc <span class="special">=</span> <span class="identifier">allocator_type</span><span class="special">(</span><span class="special">)</span><span class="special">)</span><span class="special">;</span></pre>Create a full space optimized circular buffer with the specified capacity filled with <code class="computeroutput">capacity_ctrl.capacity()</code> copies of <code class="computeroutput">item</code>. <p> 260 261 262</p> 263<p><b>Complexity. </b>Linear (in the <code class="computeroutput">capacity_ctrl.capacity()</code>). </p> 264<p> 265</p> 266<div class="variablelist"><table border="0" class="variablelist compact"> 267<colgroup> 268<col align="left" valign="top"> 269<col> 270</colgroup> 271<tbody> 272<tr> 273<td><p><span class="term">Parameters:</span></p></td> 274<td><div class="variablelist"><table border="0" class="variablelist compact"> 275<colgroup> 276<col align="left" valign="top"> 277<col> 278</colgroup> 279<tbody> 280<tr> 281<td><p><span class="term"><code class="computeroutput">alloc</code></span></p></td> 282<td><p>The allocator. </p></td> 283</tr> 284<tr> 285<td><p><span class="term"><code class="computeroutput">capacity_ctrl</code></span></p></td> 286<td><p>The capacity controller representing the maximum number of elements which can be stored in the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_idm46495624036048.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code> and the minimal allocated size of the internal buffer. </p></td> 287</tr> 288<tr> 289<td><p><span class="term"><code class="computeroutput">item</code></span></p></td> 290<td><p>The element the created <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_idm46495624036048.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code> will be filled with. </p></td> 291</tr> 292</tbody> 293</table></div></td> 294</tr> 295<tr> 296<td><p><span class="term">Postconditions:</span></p></td> 297<td><p><code class="computeroutput">capacity() == capacity_ctrl && full() && (*this)[0] == item && (*this)[1] == item && ... && (*this) [capacity_ctrl.capacity() - 1] == item </code><br> 298<br> 299 The amount of allocated memory in the internal buffer is <code class="computeroutput">capacity_ctrl.capacity()</code>. </p></td> 300</tr> 301<tr> 302<td><p><span class="term">Throws:</span></p></td> 303<td>An allocation error if memory is exhausted (<code class="computeroutput">std::bad_alloc</code> if the standard allocator is used). <code class="computeroutput">T::T(const T&)</code> throws. </td> 304</tr> 305</tbody> 306</table></div> 307</li> 308<li class="listitem"> 309<pre class="literallayout"><a name="idm46495623240352-bb"></a><span class="identifier">circular_buffer_space_optimized</span><span class="special">(</span><span class="identifier">capacity_type</span> capacity_ctrl<span class="special">,</span> <span class="identifier">size_type</span> n<span class="special">,</span> 310 <span class="identifier">param_value_type</span> item<span class="special">,</span> 311 <span class="keyword">const</span> <span class="identifier">allocator_type</span> <span class="special">&</span> alloc <span class="special">=</span> <span class="identifier">allocator_type</span><span class="special">(</span><span class="special">)</span><span class="special">)</span><span class="special">;</span></pre>Create a space optimized circular buffer with the specified capacity filled with <code class="computeroutput">n</code> copies of <code class="computeroutput">item</code>. <p> 312 313 314 315</p> 316<p><b>Complexity. </b>Linear (in the <code class="computeroutput">n</code>). </p> 317<p> 318</p> 319<div class="variablelist"><table border="0" class="variablelist compact"> 320<colgroup> 321<col align="left" valign="top"> 322<col> 323</colgroup> 324<tbody> 325<tr> 326<td><p><span class="term">Parameters:</span></p></td> 327<td><div class="variablelist"><table border="0" class="variablelist compact"> 328<colgroup> 329<col align="left" valign="top"> 330<col> 331</colgroup> 332<tbody> 333<tr> 334<td><p><span class="term"><code class="computeroutput">alloc</code></span></p></td> 335<td><p>The allocator. </p></td> 336</tr> 337<tr> 338<td><p><span class="term"><code class="computeroutput">capacity_ctrl</code></span></p></td> 339<td><p>The capacity controller representing the maximum number of elements which can be stored in the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_idm46495624036048.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code> and the minimal allocated size of the internal buffer. </p></td> 340</tr> 341<tr> 342<td><p><span class="term"><code class="computeroutput">item</code></span></p></td> 343<td><p>The element the created <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_idm46495624036048.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code> will be filled with. </p></td> 344</tr> 345<tr> 346<td><p><span class="term"><code class="computeroutput">n</code></span></p></td> 347<td><p>The number of elements the created <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_idm46495624036048.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code> will be filled with. </p></td> 348</tr> 349</tbody> 350</table></div></td> 351</tr> 352<tr> 353<td><p><span class="term">Requires:</span></p></td> 354<td><p><code class="computeroutput">capacity_ctrl.capacity() >= n</code> </p></td> 355</tr> 356<tr> 357<td><p><span class="term">Postconditions:</span></p></td> 358<td><p><code class="computeroutput">capacity() == capacity_ctrl && size() == n && (*this)[0] == item && (*this)[1] == item && ... && (*this)[n - 1] == item</code><br> 359<br> 360 The amount of allocated memory in the internal buffer is <code class="computeroutput">max[n, capacity_ctrl.min_capacity()]</code>. </p></td> 361</tr> 362<tr> 363<td><p><span class="term">Throws:</span></p></td> 364<td>An allocation error if memory is exhausted (<code class="computeroutput">std::bad_alloc</code> if the standard allocator is used). Whatever <code class="computeroutput">T::T(const T&)</code> throws. </td> 365</tr> 366</tbody> 367</table></div> 368</li> 369<li class="listitem"> 370<pre class="literallayout"><a name="idm46495623225008-bb"></a><span class="identifier">circular_buffer_space_optimized</span><span class="special">(</span><span class="keyword">const</span> <a class="link" href="circular_idm46495624036048.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a><span class="special"><</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">Alloc</span> <span class="special">></span> <span class="special">&</span> cb<span class="special">)</span><span class="special">;</span></pre>The copy constructor. <p>Creates a copy of the specified <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_idm46495624036048.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code>. 371 372 373</p> 374<p><b>Complexity. </b>Linear (in the size of <code class="computeroutput">cb</code>). </p> 375<p> 376</p> 377<div class="variablelist"><table border="0" class="variablelist compact"> 378<colgroup> 379<col align="left" valign="top"> 380<col> 381</colgroup> 382<tbody> 383<tr> 384<td><p><span class="term">Parameters:</span></p></td> 385<td><div class="variablelist"><table border="0" class="variablelist compact"> 386<colgroup> 387<col align="left" valign="top"> 388<col> 389</colgroup> 390<tbody><tr> 391<td><p><span class="term"><code class="computeroutput">cb</code></span></p></td> 392<td><p>The <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_idm46495624036048.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code> to be copied. </p></td> 393</tr></tbody> 394</table></div></td> 395</tr> 396<tr> 397<td><p><span class="term">Postconditions:</span></p></td> 398<td><p><code class="computeroutput">*this == cb</code><br> 399<br> 400 The amount of allocated memory in the internal buffer is <code class="computeroutput">cb.size()</code>. </p></td> 401</tr> 402<tr> 403<td><p><span class="term">Throws:</span></p></td> 404<td>An allocation error if memory is exhausted (<code class="computeroutput">std::bad_alloc</code> if the standard allocator is used). Whatever <code class="computeroutput">T::T(const T&)</code> throws. </td> 405</tr> 406</tbody> 407</table></div> 408</li> 409<li class="listitem"> 410<pre class="literallayout"><a name="idm46495623215776-bb"></a><span class="identifier">circular_buffer_space_optimized</span><span class="special">(</span><a class="link" href="circular_idm46495624036048.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a><span class="special"><</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">Alloc</span> <span class="special">></span> <span class="special">&&</span> cb<span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span></pre>The move constructor. <p>Move constructs a <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_idm46495624036048.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code> from <code class="computeroutput">cb</code>, leaving <code class="computeroutput">cb</code> empty. 411 412 413 414</p> 415<p><b>Constant. </b></p> 416<p> 417</p> 418<div class="variablelist"><table border="0" class="variablelist compact"> 419<colgroup> 420<col align="left" valign="top"> 421<col> 422</colgroup> 423<tbody> 424<tr> 425<td><p><span class="term">Parameters:</span></p></td> 426<td><div class="variablelist"><table border="0" class="variablelist compact"> 427<colgroup> 428<col align="left" valign="top"> 429<col> 430</colgroup> 431<tbody><tr> 432<td><p><span class="term"><code class="computeroutput">cb</code></span></p></td> 433<td><p><code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code> to 'steal' value from. </p></td> 434</tr></tbody> 435</table></div></td> 436</tr> 437<tr> 438<td><p><span class="term">Requires:</span></p></td> 439<td><p>C++ compiler with rvalue references support. </p></td> 440</tr> 441<tr> 442<td><p><span class="term">Postconditions:</span></p></td> 443<td><p><code class="computeroutput">cb.empty()</code> </p></td> 444</tr> 445<tr> 446<td><p><span class="term">Throws:</span></p></td> 447<td>Nothing. </td> 448</tr> 449</tbody> 450</table></div> 451</li> 452<li class="listitem"> 453<pre class="literallayout"><span class="keyword">template</span><span class="special"><</span><span class="keyword">typename</span> InputIterator<span class="special">></span> 454 <a name="idm46495623207584-bb"></a><span class="identifier">circular_buffer_space_optimized</span><span class="special">(</span><span class="identifier">InputIterator</span> first<span class="special">,</span> <span class="identifier">InputIterator</span> last<span class="special">,</span> 455 <span class="keyword">const</span> <span class="identifier">allocator_type</span> <span class="special">&</span> alloc <span class="special">=</span> <span class="identifier">allocator_type</span><span class="special">(</span><span class="special">)</span><span class="special">)</span><span class="special">;</span></pre>Create a full space optimized circular buffer filled with a copy of the range. <p> 456 457 458 459</p> 460<p><b>Complexity. </b>Linear (in the <code class="computeroutput">std::distance(first, last)</code>). </p> 461<p> 462</p> 463<div class="variablelist"><table border="0" class="variablelist compact"> 464<colgroup> 465<col align="left" valign="top"> 466<col> 467</colgroup> 468<tbody> 469<tr> 470<td><p><span class="term">Parameters:</span></p></td> 471<td><div class="variablelist"><table border="0" class="variablelist compact"> 472<colgroup> 473<col align="left" valign="top"> 474<col> 475</colgroup> 476<tbody> 477<tr> 478<td><p><span class="term"><code class="computeroutput">alloc</code></span></p></td> 479<td><p>The allocator. </p></td> 480</tr> 481<tr> 482<td><p><span class="term"><code class="computeroutput">first</code></span></p></td> 483<td><p>The beginning of the range to be copied. </p></td> 484</tr> 485<tr> 486<td><p><span class="term"><code class="computeroutput">last</code></span></p></td> 487<td><p>The end of the range to be copied. </p></td> 488</tr> 489</tbody> 490</table></div></td> 491</tr> 492<tr> 493<td><p><span class="term">Requires:</span></p></td> 494<td><p>Valid range <code class="computeroutput">[first, last)</code>.<br> 495 <code class="computeroutput">first</code> and <code class="computeroutput">last</code> have to meet the requirements of <a href="https://www.boost.org/sgi/stl/InputIterator.html" target="_top">InputIterator</a>. </p></td> 496</tr> 497<tr> 498<td><p><span class="term">Postconditions:</span></p></td> 499<td><p><code class="computeroutput">capacity().capacity() == std::distance(first, last) && capacity().min_capacity() == 0 && full() && (*this)[0]== *first && (*this)[1] == *(first + 1) && ... && (*this)[std::distance(first, last) - 1] == *(last - 1)</code><br> 500<br> 501 The amount of allocated memory in the internal buffer is <code class="computeroutput">std::distance(first, last)</code>. </p></td> 502</tr> 503<tr> 504<td><p><span class="term">Throws:</span></p></td> 505<td>An allocation error if memory is exhausted (<code class="computeroutput">std::bad_alloc</code> if the standard allocator is used). Whatever <code class="computeroutput">T::T(const T&)</code> throws or nothing if <code class="computeroutput">T::T(T&&)</code> is noexcept and <code class="computeroutput">InputIterator</code> is a move iterator. </td> 506</tr> 507</tbody> 508</table></div> 509</li> 510<li class="listitem"> 511<pre class="literallayout"><span class="keyword">template</span><span class="special"><</span><span class="keyword">typename</span> InputIterator<span class="special">></span> 512 <a name="idm46495623193040-bb"></a><span class="identifier">circular_buffer_space_optimized</span><span class="special">(</span><span class="identifier">capacity_type</span> capacity_ctrl<span class="special">,</span> 513 <span class="identifier">InputIterator</span> first<span class="special">,</span> <span class="identifier">InputIterator</span> last<span class="special">,</span> 514 <span class="keyword">const</span> <span class="identifier">allocator_type</span> <span class="special">&</span> alloc <span class="special">=</span> <span class="identifier">allocator_type</span><span class="special">(</span><span class="special">)</span><span class="special">)</span><span class="special">;</span></pre>Create a space optimized circular buffer with the specified capacity (and the minimal guaranteed amount of allocated memory) filled with a copy of the range. <p> 515 516 517 518</p> 519<p><b>Complexity. </b>Linear (in <code class="computeroutput">std::distance(first, last)</code>; in <code class="computeroutput">min[capacity_ctrl.capacity(), std::distance(first, last)]</code> if the <code class="computeroutput">InputIterator</code> is a <a href="https://www.boost.org/sgi/stl/RandomAccessIterator.html" target="_top">RandomAccessIterator</a>). </p> 520<p> 521</p> 522<div class="variablelist"><table border="0" class="variablelist compact"> 523<colgroup> 524<col align="left" valign="top"> 525<col> 526</colgroup> 527<tbody> 528<tr> 529<td><p><span class="term">Parameters:</span></p></td> 530<td><div class="variablelist"><table border="0" class="variablelist compact"> 531<colgroup> 532<col align="left" valign="top"> 533<col> 534</colgroup> 535<tbody> 536<tr> 537<td><p><span class="term"><code class="computeroutput">alloc</code></span></p></td> 538<td><p>The allocator. </p></td> 539</tr> 540<tr> 541<td><p><span class="term"><code class="computeroutput">capacity_ctrl</code></span></p></td> 542<td><p>The capacity controller representing the maximum number of elements which can be stored in the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_idm46495624036048.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code> and the minimal allocated size of the internal buffer. </p></td> 543</tr> 544<tr> 545<td><p><span class="term"><code class="computeroutput">first</code></span></p></td> 546<td><p>The beginning of the range to be copied. </p></td> 547</tr> 548<tr> 549<td><p><span class="term"><code class="computeroutput">last</code></span></p></td> 550<td><p>The end of the range to be copied. </p></td> 551</tr> 552</tbody> 553</table></div></td> 554</tr> 555<tr> 556<td><p><span class="term">Requires:</span></p></td> 557<td><p>Valid range <code class="computeroutput">[first, last)</code>.<br> 558 <code class="computeroutput">first</code> and <code class="computeroutput">last</code> have to meet the requirements of <a href="https://www.boost.org/sgi/stl/InputIterator.html" target="_top">InputIterator</a>. </p></td> 559</tr> 560<tr> 561<td><p><span class="term">Postconditions:</span></p></td> 562<td><p><code class="computeroutput">capacity() == capacity_ctrl && size() <= std::distance(first, last) && (*this)[0]== (last - capacity_ctrl.capacity()) && (*this)[1] == *(last - capacity_ctrl.capacity() + 1) && ... && (*this)[capacity_ctrl.capacity() - 1] == *(last - 1)</code><br> 563<br> 564 If the number of items to be copied from the range <code class="computeroutput">[first, last)</code> is greater than the specified <code class="computeroutput">capacity_ctrl.capacity()</code> then only elements from the range <code class="computeroutput">[last - capacity_ctrl.capacity(), last)</code> will be copied.<br> 565<br> 566 The amount of allocated memory in the internal buffer is <code class="computeroutput">max[capacity_ctrl.min_capacity(), min[capacity_ctrl.capacity(), std::distance(first, last)]]</code>. </p></td> 567</tr> 568<tr> 569<td><p><span class="term">Throws:</span></p></td> 570<td>An allocation error if memory is exhausted (<code class="computeroutput">std::bad_alloc</code> if the standard allocator is used). Whatever <code class="computeroutput">T::T(const T&)</code> throws. </td> 571</tr> 572</tbody> 573</table></div> 574</li> 575<li class="listitem"> 576<pre class="literallayout"><a class="link" href="circular_idm46495624036048.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a><span class="special"><</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">Alloc</span> <span class="special">></span> <span class="special">&</span> 577<a name="idm46495623173392-bb"></a><span class="keyword">operator</span><span class="special">=</span><span class="special">(</span><span class="keyword">const</span> <a class="link" href="circular_idm46495624036048.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a><span class="special"><</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">Alloc</span> <span class="special">></span> <span class="special">&</span> cb<span class="special">)</span><span class="special">;</span></pre>The assign operator. <p>Makes this <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_idm46495624036048.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code> to become a copy of the specified <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_idm46495624036048.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code>. 578 579 580</p> 581<p><b>Exception Safety. </b>Strong. </p> 582<p> 583</p> 584<p><b>Iterator Invalidation. </b>Invalidates all iterators pointing to this <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_idm46495624036048.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code> (except iterators equal to <code class="computeroutput">end()</code>). </p> 585<p> 586</p> 587<p><b>Complexity. </b>Linear (in the size of <code class="computeroutput">cb</code>). </p> 588<p> 589</p> 590<p><span class="bold"><strong>See Also:</strong></span></p> 591<p><code class="computeroutput">assign(size_type, const_reference)</code>, <code class="computeroutput">assign(capacity_type, size_type, const_reference)</code>, <code class="computeroutput">assign(InputIterator, InputIterator)</code>, <code class="computeroutput">assign(capacity_type, InputIterator, InputIterator)</code> </p> 592<p> 593</p> 594<p> 595</p> 596<div class="variablelist"><table border="0" class="variablelist compact"> 597<colgroup> 598<col align="left" valign="top"> 599<col> 600</colgroup> 601<tbody> 602<tr> 603<td><p><span class="term">Parameters:</span></p></td> 604<td><div class="variablelist"><table border="0" class="variablelist compact"> 605<colgroup> 606<col align="left" valign="top"> 607<col> 608</colgroup> 609<tbody><tr> 610<td><p><span class="term"><code class="computeroutput">cb</code></span></p></td> 611<td><p>The <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_idm46495624036048.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code> to be copied. </p></td> 612</tr></tbody> 613</table></div></td> 614</tr> 615<tr> 616<td><p><span class="term">Postconditions:</span></p></td> 617<td><p><code class="computeroutput">*this == cb</code><br> 618<br> 619 The amount of allocated memory in the internal buffer is <code class="computeroutput">cb.size()</code>. </p></td> 620</tr> 621<tr> 622<td><p><span class="term">Throws:</span></p></td> 623<td>An allocation error if memory is exhausted (<code class="computeroutput">std::bad_alloc</code> if the standard allocator is used). <code class="computeroutput">T::T(const T&)</code> throws. </td> 624</tr> 625</tbody> 626</table></div> 627</li> 628<li class="listitem"> 629<pre class="literallayout"><a class="link" href="circular_idm46495624036048.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a><span class="special"><</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">Alloc</span> <span class="special">></span> <span class="special">&</span> 630<a name="idm46495623156256-bb"></a><span class="keyword">operator</span><span class="special">=</span><span class="special">(</span><a class="link" href="circular_idm46495624036048.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a><span class="special"><</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">Alloc</span> <span class="special">></span> <span class="special">&&</span> cb<span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span></pre>Move assigns content of <code class="computeroutput">cb</code> to <code class="computeroutput">*this</code>, leaving <code class="computeroutput">cb</code> empty. <p> 631 632 633 634</p> 635<p><b>Complexity. </b>Constant. </p> 636<p> 637</p> 638<div class="variablelist"><table border="0" class="variablelist compact"> 639<colgroup> 640<col align="left" valign="top"> 641<col> 642</colgroup> 643<tbody> 644<tr> 645<td><p><span class="term">Parameters:</span></p></td> 646<td><div class="variablelist"><table border="0" class="variablelist compact"> 647<colgroup> 648<col align="left" valign="top"> 649<col> 650</colgroup> 651<tbody><tr> 652<td><p><span class="term"><code class="computeroutput">cb</code></span></p></td> 653<td><p><code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code> to 'steal' value from. </p></td> 654</tr></tbody> 655</table></div></td> 656</tr> 657<tr> 658<td><p><span class="term">Requires:</span></p></td> 659<td><p>C++ compiler with rvalue references support. </p></td> 660</tr> 661<tr> 662<td><p><span class="term">Postconditions:</span></p></td> 663<td><p><code class="computeroutput">cb.empty()</code> </p></td> 664</tr> 665<tr> 666<td><p><span class="term">Throws:</span></p></td> 667<td>Nothing. </td> 668</tr> 669</tbody> 670</table></div> 671</li> 672</ol></div> 673</div> 674<div class="refsect2"> 675<a name="id-1.3.9.16.4.3.4.4"></a><h3> 676<a name="idm46495623999456-bb"></a><code class="computeroutput">circular_buffer_space_optimized</code> public member functions</h3> 677<div class="orderedlist"><ol class="orderedlist" type="1"> 678<li class="listitem"> 679<pre class="literallayout"><span class="keyword">bool</span> <a name="idm46495623998896-bb"></a><span class="identifier">full</span><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span></pre>Is the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_idm46495624036048.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code> full? <p> 680 681</p> 682<p><b>Exception Safety. </b>No-throw. </p> 683<p> 684</p> 685<p><b>Iterator Invalidation. </b>Does not invalidate any iterators. </p> 686<p> 687</p> 688<p><b>Complexity. </b>Constant (in the size of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_idm46495624036048.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code>). </p> 689<p> 690</p> 691<p><span class="bold"><strong>See Also:</strong></span></p> 692<p><code class="computeroutput">empty()</code> </p> 693<p> 694</p> 695<p> 696</p> 697<div class="variablelist"><table border="0" class="variablelist compact"> 698<colgroup> 699<col align="left" valign="top"> 700<col> 701</colgroup> 702<tbody> 703<tr> 704<td><p><span class="term">Returns:</span></p></td> 705<td><p><code class="computeroutput">true</code> if the number of elements stored in the <code class="computeroutput"><a class="link" href="circular_idm46495624036048.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code> equals the capacity of the <code class="computeroutput"><a class="link" href="circular_idm46495624036048.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code>; <code class="computeroutput">false</code> otherwise. </p></td> 706</tr> 707<tr> 708<td><p><span class="term">Throws:</span></p></td> 709<td>Nothing. </td> 710</tr> 711</tbody> 712</table></div> 713</li> 714<li class="listitem"> 715<pre class="literallayout"><span class="identifier">size_type</span> <a name="idm46495623986800-bb"></a><span class="identifier">reserve</span><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span></pre>Get the maximum number of elements which can be inserted into the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_idm46495624036048.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code> without overwriting any of already stored elements. <p> 716 717</p> 718<p><b>Exception Safety. </b>No-throw. </p> 719<p> 720</p> 721<p><b>Iterator Invalidation. </b>Does not invalidate any iterators. </p> 722<p> 723</p> 724<p><b>Complexity. </b>Constant (in the size of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_idm46495624036048.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code>). </p> 725<p> 726</p> 727<p><span class="bold"><strong>See Also:</strong></span></p> 728<p><code class="computeroutput">capacity()</code>, <code class="computeroutput">size()</code>, <code class="computeroutput">max_size()</code> </p> 729<p> 730</p> 731<p> 732</p> 733<div class="variablelist"><table border="0" class="variablelist compact"> 734<colgroup> 735<col align="left" valign="top"> 736<col> 737</colgroup> 738<tbody> 739<tr> 740<td><p><span class="term">Returns:</span></p></td> 741<td><p><code class="computeroutput">capacity().capacity() - size()</code> </p></td> 742</tr> 743<tr> 744<td><p><span class="term">Throws:</span></p></td> 745<td>Nothing. </td> 746</tr> 747</tbody> 748</table></div> 749</li> 750<li class="listitem"> 751<pre class="literallayout"><span class="keyword">const</span> <span class="identifier">capacity_type</span> <span class="special">&</span> <a name="idm46495623975968-bb"></a><span class="identifier">capacity</span><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span></pre>Get the capacity of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_idm46495624036048.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code>. <p> 752 753</p> 754<p><b>Exception Safety. </b>No-throw. </p> 755<p> 756</p> 757<p><b>Iterator Invalidation. </b>Does not invalidate any iterators. </p> 758<p> 759</p> 760<p><b>Complexity. </b>Constant (in the size of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_idm46495624036048.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code>). </p> 761<p> 762</p> 763<p><span class="bold"><strong>See Also:</strong></span></p> 764<p><code class="computeroutput">reserve()</code>, <code class="computeroutput">size()</code>, <code class="computeroutput">max_size()</code>, <code class="computeroutput">set_capacity(const capacity_type&)</code> </p> 765<p> 766</p> 767<p> 768</p> 769<div class="variablelist"><table border="0" class="variablelist compact"> 770<colgroup> 771<col align="left" valign="top"> 772<col> 773</colgroup> 774<tbody> 775<tr> 776<td><p><span class="term">Returns:</span></p></td> 777<td><p>The capacity controller representing the maximum number of elements which can be stored in the <code class="computeroutput"><a class="link" href="circular_idm46495624036048.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code> and the minimal allocated size of the internal buffer. </p></td> 778</tr> 779<tr> 780<td><p><span class="term">Throws:</span></p></td> 781<td>Nothing. </td> 782</tr> 783</tbody> 784</table></div> 785</li> 786<li class="listitem"> 787<pre class="literallayout"><span class="keyword">void</span> <a name="idm46495623964032-bb"></a><span class="identifier">set_capacity</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">capacity_type</span> <span class="special">&</span> capacity_ctrl<span class="special">)</span><span class="special">;</span></pre>Change the capacity (and the minimal guaranteed amount of allocated memory) of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_idm46495624036048.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code>. <p> 788 789 790</p> 791<p><b>Exception Safety. </b>Strong. </p> 792<p> 793</p> 794<p><b>Iterator Invalidation. </b>Invalidates all iterators pointing to the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_idm46495624036048.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code> (except iterators equal to <code class="computeroutput">end()</code>). </p> 795<p> 796</p> 797<p><b>Complexity. </b>Linear (in <code class="computeroutput">min[size(), capacity_ctrl.capacity()]</code>). </p> 798<p> 799</p> 800<div class="note"><table border="0" summary="Note"> 801<tr> 802<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../doc/src/images/note.png"></td> 803<th align="left">Note</th> 804</tr> 805<tr><td align="left" valign="top"><p>To explicitly clear the extra allocated memory use the <span class="bold"><strong>shrink-to-fit</strong></span> technique:<br> 806<br> 807 <code class="computeroutput">boost::circular_buffer_space_optimized<int> cb(1000);<br> 808 ...<br> 809 boost::circular_buffer_space_optimized<int>(cb).swap(cb);</code><br> 810<br> 811 For more information about the shrink-to-fit technique in STL see <a href="http://www.gotw.ca/gotw/054.htm" target="_top">http://www.gotw.ca/gotw/054.htm</a>. </p></td></tr> 812</table></div> 813<p> 814</p> 815<p><span class="bold"><strong>See Also:</strong></span></p> 816<p><code class="computeroutput">rset_capacity(const capacity_type&)</code>, <code class="computeroutput">resize(size_type, const_reference)</code> </p> 817<p> 818</p> 819<p> 820</p> 821<div class="variablelist"><table border="0" class="variablelist compact"> 822<colgroup> 823<col align="left" valign="top"> 824<col> 825</colgroup> 826<tbody> 827<tr> 828<td><p><span class="term">Parameters:</span></p></td> 829<td><div class="variablelist"><table border="0" class="variablelist compact"> 830<colgroup> 831<col align="left" valign="top"> 832<col> 833</colgroup> 834<tbody><tr> 835<td><p><span class="term"><code class="computeroutput">capacity_ctrl</code></span></p></td> 836<td><p>The new capacity controller. </p></td> 837</tr></tbody> 838</table></div></td> 839</tr> 840<tr> 841<td><p><span class="term">Postconditions:</span></p></td> 842<td><p><code class="computeroutput">capacity() == capacity_ctrl && size() <= capacity_ctrl.capacity()</code><br> 843<br> 844 If the current number of elements stored in the <code class="computeroutput"><a class="link" href="circular_idm46495624036048.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code> is greater than the desired new capacity then number of <code class="computeroutput">[size() - capacity_ctrl.capacity()]</code> <span class="bold"><strong>last</strong></span> elements will be removed and the new size will be equal to <code class="computeroutput">capacity_ctrl.capacity()</code>.<br> 845<br> 846 If the current number of elements stored in the <code class="computeroutput"><a class="link" href="circular_idm46495624036048.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code> is lower than the new capacity then the amount of allocated memory in the internal buffer may be accommodated as necessary but it will never drop below <code class="computeroutput">capacity_ctrl.min_capacity()</code>. </p></td> 847</tr> 848<tr> 849<td><p><span class="term">Throws:</span></p></td> 850<td>An allocation error if memory is exhausted, (<code class="computeroutput">std::bad_alloc</code> if the standard allocator is used). Whatever <code class="computeroutput">T::T(const T&)</code> throws or nothing if <code class="computeroutput">T::T(T&&)</code> is noexcept. </td> 851</tr> 852</tbody> 853</table></div> 854</li> 855<li class="listitem"> 856<pre class="literallayout"><span class="keyword">void</span> <a name="idm46495623940880-bb"></a><span class="identifier">resize</span><span class="special">(</span><span class="identifier">size_type</span> new_size<span class="special">,</span> <span class="identifier">param_value_type</span> item <span class="special">=</span> <span class="identifier">value_type</span><span class="special">(</span><span class="special">)</span><span class="special">)</span><span class="special">;</span></pre>Change the size of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_idm46495624036048.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code>. <p> 857 858 859</p> 860<p><b>Exception Safety. </b>Basic. </p> 861<p> 862</p> 863<p><b>Iterator Invalidation. </b>Invalidates all iterators pointing to the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_idm46495624036048.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code> (except iterators equal to <code class="computeroutput">end()</code>). </p> 864<p> 865</p> 866<p><b>Complexity. </b>Linear (in the new size of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_idm46495624036048.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code>). </p> 867<p> 868</p> 869<p><span class="bold"><strong>See Also:</strong></span></p> 870<p><code class="computeroutput">rresize(size_type, const_reference)</code>, <code class="computeroutput">set_capacity(const capacity_type&)</code> </p> 871<p> 872</p> 873<p> 874</p> 875<div class="variablelist"><table border="0" class="variablelist compact"> 876<colgroup> 877<col align="left" valign="top"> 878<col> 879</colgroup> 880<tbody> 881<tr> 882<td><p><span class="term">Parameters:</span></p></td> 883<td><div class="variablelist"><table border="0" class="variablelist compact"> 884<colgroup> 885<col align="left" valign="top"> 886<col> 887</colgroup> 888<tbody> 889<tr> 890<td><p><span class="term"><code class="computeroutput">item</code></span></p></td> 891<td><p>The element the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_idm46495624036048.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code> will be filled with in order to gain the requested size. (See the <span class="emphasis"><em>Effect</em></span>.) </p></td> 892</tr> 893<tr> 894<td><p><span class="term"><code class="computeroutput">new_size</code></span></p></td> 895<td><p>The new size. </p></td> 896</tr> 897</tbody> 898</table></div></td> 899</tr> 900<tr> 901<td><p><span class="term">Postconditions:</span></p></td> 902<td><p><code class="computeroutput">size() == new_size && capacity().capacity() >= new_size</code><br> 903<br> 904 If the new size is greater than the current size, copies of <code class="computeroutput">item</code> will be inserted at the <span class="bold"><strong>back</strong></span> of the of the <code class="computeroutput"><a class="link" href="circular_idm46495624036048.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code> in order to achieve the desired size. In the case the resulting size exceeds the current capacity the capacity will be set to <code class="computeroutput">new_size</code>.<br> 905<br> 906 If the current number of elements stored in the <code class="computeroutput"><a class="link" href="circular_idm46495624036048.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code> is greater than the desired new size then number of <code class="computeroutput">[size() - new_size]</code> <span class="bold"><strong>last</strong></span> elements will be removed. (The capacity will remain unchanged.)<br> 907<br> 908 The amount of allocated memory in the internal buffer may be accommodated as necessary. </p></td> 909</tr> 910<tr> 911<td><p><span class="term">Throws:</span></p></td> 912<td>An allocation error if memory is exhausted (<code class="computeroutput">std::bad_alloc</code> if the standard allocator is used). Whatever <code class="computeroutput">T::T(const T&)</code> throws. </td> 913</tr> 914</tbody> 915</table></div> 916</li> 917<li class="listitem"> 918<pre class="literallayout"><span class="keyword">void</span> <a name="idm46495623918144-bb"></a><span class="identifier">rset_capacity</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">capacity_type</span> <span class="special">&</span> capacity_ctrl<span class="special">)</span><span class="special">;</span></pre>Change the capacity (and the minimal guaranteed amount of allocated memory) of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_idm46495624036048.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code>. <p> 919 920 921</p> 922<p><b>Exception Safety. </b>Strong. </p> 923<p> 924</p> 925<p><b>Iterator Invalidation. </b>Invalidates all iterators pointing to the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_idm46495624036048.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code> (except iterators equal to <code class="computeroutput">end()</code>). </p> 926<p> 927</p> 928<p><b>Complexity. </b>Linear (in <code class="computeroutput">min[size(), capacity_ctrl.capacity()]</code>). </p> 929<p> 930</p> 931<p><span class="bold"><strong>See Also:</strong></span></p> 932<p><code class="computeroutput">set_capacity(const capacity_type&)</code>, <code class="computeroutput">rresize(size_type, const_reference)</code> </p> 933<p> 934</p> 935<p> 936</p> 937<div class="variablelist"><table border="0" class="variablelist compact"> 938<colgroup> 939<col align="left" valign="top"> 940<col> 941</colgroup> 942<tbody> 943<tr> 944<td><p><span class="term">Parameters:</span></p></td> 945<td><div class="variablelist"><table border="0" class="variablelist compact"> 946<colgroup> 947<col align="left" valign="top"> 948<col> 949</colgroup> 950<tbody><tr> 951<td><p><span class="term"><code class="computeroutput">capacity_ctrl</code></span></p></td> 952<td><p>The new capacity controller. </p></td> 953</tr></tbody> 954</table></div></td> 955</tr> 956<tr> 957<td><p><span class="term">Postconditions:</span></p></td> 958<td><p><code class="computeroutput">capacity() == capacity_ctrl && size() <= capacity_ctrl</code><br> 959<br> 960 If the current number of elements stored in the <code class="computeroutput"><a class="link" href="circular_idm46495624036048.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code> is greater than the desired new capacity then number of <code class="computeroutput">[size() - capacity_ctrl.capacity()]</code> <span class="bold"><strong>first</strong></span> elements will be removed and the new size will be equal to <code class="computeroutput">capacity_ctrl.capacity()</code>.<br> 961<br> 962 If the current number of elements stored in the <code class="computeroutput"><a class="link" href="circular_idm46495624036048.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code> is lower than the new capacity then the amount of allocated memory in the internal buffer may be accommodated as necessary but it will never drop below <code class="computeroutput">capacity_ctrl.min_capacity()</code>. </p></td> 963</tr> 964<tr> 965<td><p><span class="term">Throws:</span></p></td> 966<td>An allocation error if memory is exhausted (<code class="computeroutput">std::bad_alloc</code> if the standard allocator is used). Whatever <code class="computeroutput">T::T(const T&)</code> throws or nothing if <code class="computeroutput">T::T(T&&)</code> is noexcept. </td> 967</tr> 968</tbody> 969</table></div> 970</li> 971<li class="listitem"> 972<pre class="literallayout"><span class="keyword">void</span> <a name="idm46495623899392-bb"></a><span class="identifier">rresize</span><span class="special">(</span><span class="identifier">size_type</span> new_size<span class="special">,</span> <span class="identifier">param_value_type</span> item <span class="special">=</span> <span class="identifier">value_type</span><span class="special">(</span><span class="special">)</span><span class="special">)</span><span class="special">;</span></pre>Change the size of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_idm46495624036048.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code>. <p> 973 974 975</p> 976<p><b>Exception Safety. </b>Basic. </p> 977<p> 978</p> 979<p><b>Iterator Invalidation. </b>Invalidates all iterators pointing to the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_idm46495624036048.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code> (except iterators equal to <code class="computeroutput">end()</code>). </p> 980<p> 981</p> 982<p><b>Complexity. </b>Linear (in the new size of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_idm46495624036048.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code>). </p> 983<p> 984</p> 985<p><span class="bold"><strong>See Also:</strong></span></p> 986<p><code class="computeroutput">resize(size_type, const_reference)</code>, <code class="computeroutput">rset_capacity(const capacity_type&)</code> </p> 987<p> 988</p> 989<p> 990</p> 991<div class="variablelist"><table border="0" class="variablelist compact"> 992<colgroup> 993<col align="left" valign="top"> 994<col> 995</colgroup> 996<tbody> 997<tr> 998<td><p><span class="term">Parameters:</span></p></td> 999<td><div class="variablelist"><table border="0" class="variablelist compact"> 1000<colgroup> 1001<col align="left" valign="top"> 1002<col> 1003</colgroup> 1004<tbody> 1005<tr> 1006<td><p><span class="term"><code class="computeroutput">item</code></span></p></td> 1007<td><p>The element the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_idm46495624036048.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code> will be filled with in order to gain the requested size. (See the <span class="emphasis"><em>Effect</em></span>.) </p></td> 1008</tr> 1009<tr> 1010<td><p><span class="term"><code class="computeroutput">new_size</code></span></p></td> 1011<td><p>The new size. </p></td> 1012</tr> 1013</tbody> 1014</table></div></td> 1015</tr> 1016<tr> 1017<td><p><span class="term">Postconditions:</span></p></td> 1018<td><p><code class="computeroutput">size() == new_size && capacity().capacity() >= new_size</code><br> 1019<br> 1020 If the new size is greater than the current size, copies of <code class="computeroutput">item</code> will be inserted at the <span class="bold"><strong>front</strong></span> of the of the <code class="computeroutput"><a class="link" href="circular_idm46495624036048.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code> in order to achieve the desired size. In the case the resulting size exceeds the current capacity the capacity will be set to <code class="computeroutput">new_size</code>.<br> 1021<br> 1022 If the current number of elements stored in the <code class="computeroutput"><a class="link" href="circular_idm46495624036048.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code> is greater than the desired new size then number of <code class="computeroutput">[size() - new_size]</code> <span class="bold"><strong>first</strong></span> elements will be removed. (The capacity will remain unchanged.)<br> 1023<br> 1024 The amount of allocated memory in the internal buffer may be accommodated as necessary. </p></td> 1025</tr> 1026<tr> 1027<td><p><span class="term">Throws:</span></p></td> 1028<td>An allocation error if memory is exhausted (<code class="computeroutput">std::bad_alloc</code> if the standard allocator is used). Whatever <code class="computeroutput">T::T(const T&)</code> throws. </td> 1029</tr> 1030</tbody> 1031</table></div> 1032</li> 1033<li class="listitem"> 1034<pre class="literallayout"><span class="keyword">void</span> <a name="idm46495623876656-bb"></a><span class="identifier">assign</span><span class="special">(</span><span class="identifier">size_type</span> n<span class="special">,</span> <span class="identifier">param_value_type</span> item<span class="special">)</span><span class="special">;</span></pre>Assign <code class="computeroutput">n</code> items into the space optimized circular buffer. <p>The content of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_idm46495624036048.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code> will be removed and replaced with <code class="computeroutput">n</code> copies of the <code class="computeroutput">item</code>. 1035 1036 1037</p> 1038<p><b>Exception Safety. </b>Basic. </p> 1039<p> 1040</p> 1041<p><b>Iterator Invalidation. </b>Invalidates all iterators pointing to the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_idm46495624036048.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code> (except iterators equal to <code class="computeroutput">end()</code>). </p> 1042<p> 1043</p> 1044<p><b>Complexity. </b>Linear (in the <code class="computeroutput">n</code>). </p> 1045<p> 1046</p> 1047<p><span class="bold"><strong>See Also:</strong></span></p> 1048<p><code class="computeroutput">operator=</code>, <code class="computeroutput">assign(capacity_type, size_type, const_reference)</code>, <code class="computeroutput">assign(InputIterator, InputIterator)</code>, <code class="computeroutput">assign(capacity_type, InputIterator, InputIterator)</code> </p> 1049<p> 1050</p> 1051<p> 1052</p> 1053<div class="variablelist"><table border="0" class="variablelist compact"> 1054<colgroup> 1055<col align="left" valign="top"> 1056<col> 1057</colgroup> 1058<tbody> 1059<tr> 1060<td><p><span class="term">Parameters:</span></p></td> 1061<td><div class="variablelist"><table border="0" class="variablelist compact"> 1062<colgroup> 1063<col align="left" valign="top"> 1064<col> 1065</colgroup> 1066<tbody> 1067<tr> 1068<td><p><span class="term"><code class="computeroutput">item</code></span></p></td> 1069<td><p>The element the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_idm46495624036048.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code> will be filled with. </p></td> 1070</tr> 1071<tr> 1072<td><p><span class="term"><code class="computeroutput">n</code></span></p></td> 1073<td><p>The number of elements the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_idm46495624036048.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code> will be filled with. </p></td> 1074</tr> 1075</tbody> 1076</table></div></td> 1077</tr> 1078<tr> 1079<td><p><span class="term">Postconditions:</span></p></td> 1080<td><p><code class="computeroutput">capacity().capacity() == n && capacity().min_capacity() == 0 && size() == n && (*this)[0] == item && (*this)[1] == item && ... && (*this) [n - 1] == item</code><br> 1081<br> 1082 The amount of allocated memory in the internal buffer is <code class="computeroutput">n</code>. </p></td> 1083</tr> 1084<tr> 1085<td><p><span class="term">Throws:</span></p></td> 1086<td>An allocation error if memory is exhausted (<code class="computeroutput">std::bad_alloc</code> if the standard allocator is used). Whatever <code class="computeroutput">T::T(const T&)</code> throws. </td> 1087</tr> 1088</tbody> 1089</table></div> 1090</li> 1091<li class="listitem"> 1092<pre class="literallayout"><span class="keyword">void</span> <a name="idm46495623857376-bb"></a><span class="identifier">assign</span><span class="special">(</span><span class="identifier">capacity_type</span> capacity_ctrl<span class="special">,</span> <span class="identifier">size_type</span> n<span class="special">,</span> <span class="identifier">param_value_type</span> item<span class="special">)</span><span class="special">;</span></pre>Assign <code class="computeroutput">n</code> items into the space optimized circular buffer specifying the capacity. <p>The capacity of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_idm46495624036048.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code> will be set to the specified value and the content of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_idm46495624036048.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code> will be removed and replaced with <code class="computeroutput">n</code> copies of the <code class="computeroutput">item</code>. 1093 1094 1095 1096</p> 1097<p><b>Exception Safety. </b>Basic. </p> 1098<p> 1099</p> 1100<p><b>Iterator Invalidation. </b>Invalidates all iterators pointing to the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_idm46495624036048.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code> (except iterators equal to <code class="computeroutput">end()</code>). </p> 1101<p> 1102</p> 1103<p><b>Complexity. </b>Linear (in the <code class="computeroutput">n</code>). </p> 1104<p> 1105</p> 1106<p><span class="bold"><strong>See Also:</strong></span></p> 1107<p><code class="computeroutput">operator=</code>, <code class="computeroutput">assign(size_type, const_reference)</code>, <code class="computeroutput">assign(InputIterator, InputIterator)</code>, <code class="computeroutput">assign(capacity_type, InputIterator, InputIterator)</code> </p> 1108<p> 1109</p> 1110<p> 1111</p> 1112<div class="variablelist"><table border="0" class="variablelist compact"> 1113<colgroup> 1114<col align="left" valign="top"> 1115<col> 1116</colgroup> 1117<tbody> 1118<tr> 1119<td><p><span class="term">Parameters:</span></p></td> 1120<td><div class="variablelist"><table border="0" class="variablelist compact"> 1121<colgroup> 1122<col align="left" valign="top"> 1123<col> 1124</colgroup> 1125<tbody> 1126<tr> 1127<td><p><span class="term"><code class="computeroutput">capacity_ctrl</code></span></p></td> 1128<td><p>The new capacity controller. </p></td> 1129</tr> 1130<tr> 1131<td><p><span class="term"><code class="computeroutput">item</code></span></p></td> 1132<td><p>The element the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_idm46495624036048.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code> will be filled with. </p></td> 1133</tr> 1134<tr> 1135<td><p><span class="term"><code class="computeroutput">n</code></span></p></td> 1136<td><p>The number of elements the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_idm46495624036048.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code> will be filled with. </p></td> 1137</tr> 1138</tbody> 1139</table></div></td> 1140</tr> 1141<tr> 1142<td><p><span class="term">Requires:</span></p></td> 1143<td><p><code class="computeroutput">capacity_ctrl.capacity() >= n</code> </p></td> 1144</tr> 1145<tr> 1146<td><p><span class="term">Postconditions:</span></p></td> 1147<td><p><code class="computeroutput">capacity() == capacity_ctrl && size() == n && (*this)[0] == item && (*this)[1] == item && ... && (*this) [n - 1] == item </code><br> 1148<br> 1149 The amount of allocated memory will be <code class="computeroutput">max[n, capacity_ctrl.min_capacity()]</code>. </p></td> 1150</tr> 1151<tr> 1152<td><p><span class="term">Throws:</span></p></td> 1153<td>An allocation error if memory is exhausted (<code class="computeroutput">std::bad_alloc</code> if the standard allocator is used). Whatever <code class="computeroutput">T::T(const T&)</code> throws. </td> 1154</tr> 1155</tbody> 1156</table></div> 1157</li> 1158<li class="listitem"> 1159<pre class="literallayout"><span class="keyword">template</span><span class="special"><</span><span class="keyword">typename</span> InputIterator<span class="special">></span> 1160 <span class="keyword">void</span> <a name="idm46495623835184-bb"></a><span class="identifier">assign</span><span class="special">(</span><span class="identifier">InputIterator</span> first<span class="special">,</span> <span class="identifier">InputIterator</span> last<span class="special">)</span><span class="special">;</span></pre>Assign a copy of the range into the space optimized circular buffer. <p>The content of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_idm46495624036048.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code> will be removed and replaced with copies of elements from the specified range. 1161 1162 1163 1164</p> 1165<p><b>Exception Safety. </b>Basic. </p> 1166<p> 1167</p> 1168<p><b>Iterator Invalidation. </b>Invalidates all iterators pointing to the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_idm46495624036048.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code> (except iterators equal to <code class="computeroutput">end()</code>). </p> 1169<p> 1170</p> 1171<p><b>Complexity. </b>Linear (in the <code class="computeroutput">std::distance(first, last)</code>). </p> 1172<p> 1173</p> 1174<p><span class="bold"><strong>See Also:</strong></span></p> 1175<p><code class="computeroutput">operator=</code>, <code class="computeroutput">assign(size_type, const_reference)</code>, <code class="computeroutput">assign(capacity_type, size_type, const_reference)</code>, <code class="computeroutput">assign(capacity_type, InputIterator, InputIterator)</code> </p> 1176<p> 1177</p> 1178<p> 1179</p> 1180<div class="variablelist"><table border="0" class="variablelist compact"> 1181<colgroup> 1182<col align="left" valign="top"> 1183<col> 1184</colgroup> 1185<tbody> 1186<tr> 1187<td><p><span class="term">Parameters:</span></p></td> 1188<td><div class="variablelist"><table border="0" class="variablelist compact"> 1189<colgroup> 1190<col align="left" valign="top"> 1191<col> 1192</colgroup> 1193<tbody> 1194<tr> 1195<td><p><span class="term"><code class="computeroutput">first</code></span></p></td> 1196<td><p>The beginning of the range to be copied. </p></td> 1197</tr> 1198<tr> 1199<td><p><span class="term"><code class="computeroutput">last</code></span></p></td> 1200<td><p>The end of the range to be copied. </p></td> 1201</tr> 1202</tbody> 1203</table></div></td> 1204</tr> 1205<tr> 1206<td><p><span class="term">Requires:</span></p></td> 1207<td><p>Valid range <code class="computeroutput">[first, last)</code>.<br> 1208 <code class="computeroutput">first</code> and <code class="computeroutput">last</code> have to meet the requirements of <a href="https://www.boost.org/sgi/stl/InputIterator.html" target="_top">InputIterator</a>. </p></td> 1209</tr> 1210<tr> 1211<td><p><span class="term">Postconditions:</span></p></td> 1212<td><p><code class="computeroutput">capacity().capacity() == std::distance(first, last) && capacity().min_capacity() == 0 && size() == std::distance(first, last) && (*this)[0]== *first && (*this)[1] == *(first + 1) && ... && (*this)[std::distance(first, last) - 1] == *(last - 1)</code><br> 1213<br> 1214 The amount of allocated memory in the internal buffer is <code class="computeroutput">std::distance(first, last)</code>. </p></td> 1215</tr> 1216<tr> 1217<td><p><span class="term">Throws:</span></p></td> 1218<td>An allocation error if memory is exhausted (<code class="computeroutput">std::bad_alloc</code> if the standard allocator is used). Whatever <code class="computeroutput">T::T(const T&)</code> throws or nothing if <code class="computeroutput">T::T(T&&)</code> is noexcept and <code class="computeroutput">InputIterator</code> is a move iterator. </td> 1219</tr> 1220</tbody> 1221</table></div> 1222</li> 1223<li class="listitem"> 1224<pre class="literallayout"><span class="keyword">template</span><span class="special"><</span><span class="keyword">typename</span> InputIterator<span class="special">></span> 1225 <span class="keyword">void</span> <a name="idm46495623814080-bb"></a><span class="identifier">assign</span><span class="special">(</span><span class="identifier">capacity_type</span> capacity_ctrl<span class="special">,</span> <span class="identifier">InputIterator</span> first<span class="special">,</span> 1226 <span class="identifier">InputIterator</span> last<span class="special">)</span><span class="special">;</span></pre>Assign a copy of the range into the space optimized circular buffer specifying the capacity. <p>The capacity of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_idm46495624036048.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code> will be set to the specified value and the content of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_idm46495624036048.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code> will be removed and replaced with copies of elements from the specified range. 1227 1228 1229 1230</p> 1231<p><b>Exception Safety. </b>Basic. </p> 1232<p> 1233</p> 1234<p><b>Iterator Invalidation. </b>Invalidates all iterators pointing to the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_idm46495624036048.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code> (except iterators equal to <code class="computeroutput">end()</code>). </p> 1235<p> 1236</p> 1237<p><b>Complexity. </b>Linear (in <code class="computeroutput">std::distance(first, last)</code>; in <code class="computeroutput">min[capacity_ctrl.capacity(), std::distance(first, last)]</code> if the <code class="computeroutput">InputIterator</code> is a <a href="https://www.boost.org/sgi/stl/RandomAccessIterator.html" target="_top">RandomAccessIterator</a>). </p> 1238<p> 1239</p> 1240<p><span class="bold"><strong>See Also:</strong></span></p> 1241<p><code class="computeroutput">operator=</code>, <code class="computeroutput">assign(size_type, const_reference)</code>, <code class="computeroutput">assign(capacity_type, size_type, const_reference)</code>, <code class="computeroutput">assign(InputIterator, InputIterator)</code> </p> 1242<p> 1243</p> 1244<p> 1245</p> 1246<div class="variablelist"><table border="0" class="variablelist compact"> 1247<colgroup> 1248<col align="left" valign="top"> 1249<col> 1250</colgroup> 1251<tbody> 1252<tr> 1253<td><p><span class="term">Parameters:</span></p></td> 1254<td><div class="variablelist"><table border="0" class="variablelist compact"> 1255<colgroup> 1256<col align="left" valign="top"> 1257<col> 1258</colgroup> 1259<tbody> 1260<tr> 1261<td><p><span class="term"><code class="computeroutput">capacity_ctrl</code></span></p></td> 1262<td><p>The new capacity controller. </p></td> 1263</tr> 1264<tr> 1265<td><p><span class="term"><code class="computeroutput">first</code></span></p></td> 1266<td><p>The beginning of the range to be copied. </p></td> 1267</tr> 1268<tr> 1269<td><p><span class="term"><code class="computeroutput">last</code></span></p></td> 1270<td><p>The end of the range to be copied. </p></td> 1271</tr> 1272</tbody> 1273</table></div></td> 1274</tr> 1275<tr> 1276<td><p><span class="term">Requires:</span></p></td> 1277<td><p>Valid range <code class="computeroutput">[first, last)</code>.<br> 1278 <code class="computeroutput">first</code> and <code class="computeroutput">last</code> have to meet the requirements of <a href="https://www.boost.org/sgi/stl/InputIterator.html" target="_top">InputIterator</a>. </p></td> 1279</tr> 1280<tr> 1281<td><p><span class="term">Postconditions:</span></p></td> 1282<td><p><code class="computeroutput">capacity() == capacity_ctrl && size() <= std::distance(first, last) && (*this)[0]== *(last - capacity) && (*this)[1] == *(last - capacity + 1) && ... && (*this)[capacity - 1] == *(last - 1)</code><br> 1283<br> 1284 If the number of items to be copied from the range <code class="computeroutput">[first, last)</code> is greater than the specified <code class="computeroutput">capacity</code> then only elements from the range <code class="computeroutput">[last - capacity, last)</code> will be copied.<br> 1285<br> 1286 The amount of allocated memory in the internal buffer is <code class="computeroutput">max[std::distance(first, last), capacity_ctrl.min_capacity()]</code>. </p></td> 1287</tr> 1288<tr> 1289<td><p><span class="term">Throws:</span></p></td> 1290<td>An allocation error if memory is exhausted (<code class="computeroutput">std::bad_alloc</code> if the standard allocator is used). Whatever <code class="computeroutput">T::T(const T&)</code> throws or nothing if <code class="computeroutput">T::T(T&&)</code> is noexcept and <code class="computeroutput">InputIterator</code> is a move iterator. </td> 1291</tr> 1292</tbody> 1293</table></div> 1294</li> 1295<li class="listitem"> 1296<pre class="literallayout"><span class="keyword">void</span> <a name="idm46495623787248-bb"></a><span class="identifier">swap</span><span class="special">(</span><a class="link" href="circular_idm46495624036048.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a><span class="special"><</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">Alloc</span> <span class="special">></span> <span class="special">&</span> cb<span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span></pre>Swap the contents of two space-optimized circular-buffers. <p> 1297 1298 1299</p> 1300<p><b>Exception Safety. </b>No-throw. </p> 1301<p> 1302</p> 1303<p><b>Iterator Invalidation. </b>Invalidates all iterators of both <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_idm46495624036048.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code> containers. (On the other hand the iterators still point to the same elements but within another container. If you want to rely on this feature you have to turn the __debug_support off, otherwise an assertion will report an error if such invalidated iterator is used.) </p> 1304<p> 1305</p> 1306<p><b>Complexity. </b>Constant (in the size of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_idm46495624036048.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code>). </p> 1307<p> 1308</p> 1309<p><span class="bold"><strong>See Also:</strong></span></p> 1310<p><code class="computeroutput">swap(circular_buffer<T, Alloc>&, circular_buffer<T, Alloc>&)</code>, <code class="computeroutput">swap(circular_buffer_space_optimized<T, Alloc>&, circular_buffer_space_optimized<T, Alloc>&)</code> </p> 1311<p> 1312</p> 1313<p> 1314</p> 1315<div class="variablelist"><table border="0" class="variablelist compact"> 1316<colgroup> 1317<col align="left" valign="top"> 1318<col> 1319</colgroup> 1320<tbody> 1321<tr> 1322<td><p><span class="term">Parameters:</span></p></td> 1323<td><div class="variablelist"><table border="0" class="variablelist compact"> 1324<colgroup> 1325<col align="left" valign="top"> 1326<col> 1327</colgroup> 1328<tbody><tr> 1329<td><p><span class="term"><code class="computeroutput">cb</code></span></p></td> 1330<td><p>The <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_idm46495624036048.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code> whose content will be swapped. </p></td> 1331</tr></tbody> 1332</table></div></td> 1333</tr> 1334<tr> 1335<td><p><span class="term">Postconditions:</span></p></td> 1336<td><p><code class="computeroutput">this</code> contains elements of <code class="computeroutput">cb</code> and vice versa; the capacity and the amount of allocated memory in the internal buffer of <code class="computeroutput">this</code> equal to the capacity and the amount of allocated memory of <code class="computeroutput">cb</code> and vice versa. </p></td> 1337</tr> 1338<tr> 1339<td><p><span class="term">Throws:</span></p></td> 1340<td>Nothing. </td> 1341</tr> 1342</tbody> 1343</table></div> 1344</li> 1345<li class="listitem"> 1346<pre class="literallayout"><span class="keyword">void</span> <a name="idm46495623772752-bb"></a><span class="identifier">push_back</span><span class="special">(</span><span class="identifier">param_value_type</span> item<span class="special">)</span><span class="special">;</span></pre>Insert a new element at the end of the space optimized circular buffer. <p> 1347 1348 1349</p> 1350<p><b>Exception Safety. </b>Basic. </p> 1351<p> 1352</p> 1353<p><b>Iterator Invalidation. </b>Invalidates all iterators pointing to the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_idm46495624036048.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code> (except iterators equal to <code class="computeroutput">end()</code>). </p> 1354<p> 1355</p> 1356<p><b>Complexity. </b>Linear (in the size of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_idm46495624036048.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code>). </p> 1357<p> 1358</p> 1359<p><span class="bold"><strong>See Also:</strong></span></p> 1360<p><code class="computeroutput">push_front(const_reference)</code>, <code class="computeroutput">pop_back()</code>, <code class="computeroutput">pop_front()</code> </p> 1361<p> 1362</p> 1363<p> 1364</p> 1365<div class="variablelist"><table border="0" class="variablelist compact"> 1366<colgroup> 1367<col align="left" valign="top"> 1368<col> 1369</colgroup> 1370<tbody> 1371<tr> 1372<td><p><span class="term">Parameters:</span></p></td> 1373<td><div class="variablelist"><table border="0" class="variablelist compact"> 1374<colgroup> 1375<col align="left" valign="top"> 1376<col> 1377</colgroup> 1378<tbody><tr> 1379<td><p><span class="term"><code class="computeroutput">item</code></span></p></td> 1380<td><p>The element to be inserted. </p></td> 1381</tr></tbody> 1382</table></div></td> 1383</tr> 1384<tr> 1385<td><p><span class="term">Postconditions:</span></p></td> 1386<td><p>if <code class="computeroutput">capacity().capacity() > 0</code> then <code class="computeroutput">back() == item</code><br> 1387 If the <code class="computeroutput"><a class="link" href="circular_idm46495624036048.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code> is full, the first element will be removed. If the capacity is <code class="computeroutput">0</code>, nothing will be inserted.<br> 1388<br> 1389 The amount of allocated memory in the internal buffer may be predictively increased. </p></td> 1390</tr> 1391<tr> 1392<td><p><span class="term">Throws:</span></p></td> 1393<td>An allocation error if memory is exhausted (<code class="computeroutput">std::bad_alloc</code> if the standard allocator is used). Whatever <code class="computeroutput">T::T(const T&)</code> throws. </td> 1394</tr> 1395</tbody> 1396</table></div> 1397</li> 1398<li class="listitem"> 1399<pre class="literallayout"><span class="keyword">void</span> <a name="idm46495623756880-bb"></a><span class="identifier">push_back</span><span class="special">(</span><span class="identifier">rvalue_type</span> item<span class="special">)</span><span class="special">;</span></pre>Insert a new element at the end of the space optimized circular buffer. <p> 1400 1401 1402</p> 1403<p><b>Exception Safety. </b>Basic. </p> 1404<p> 1405</p> 1406<p><b>Iterator Invalidation. </b>Invalidates all iterators pointing to the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_idm46495624036048.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code> (except iterators equal to <code class="computeroutput">end()</code>). </p> 1407<p> 1408</p> 1409<p><b>Complexity. </b>Linear (in the size of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_idm46495624036048.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code>). </p> 1410<p> 1411</p> 1412<p><span class="bold"><strong>See Also:</strong></span></p> 1413<p><code class="computeroutput">push_front(const_reference)</code>, <code class="computeroutput">pop_back()</code>, <code class="computeroutput">pop_front()</code> </p> 1414<p> 1415</p> 1416<p> 1417</p> 1418<div class="variablelist"><table border="0" class="variablelist compact"> 1419<colgroup> 1420<col align="left" valign="top"> 1421<col> 1422</colgroup> 1423<tbody> 1424<tr> 1425<td><p><span class="term">Parameters:</span></p></td> 1426<td><div class="variablelist"><table border="0" class="variablelist compact"> 1427<colgroup> 1428<col align="left" valign="top"> 1429<col> 1430</colgroup> 1431<tbody><tr> 1432<td><p><span class="term"><code class="computeroutput">item</code></span></p></td> 1433<td><p>The element to be inserted. </p></td> 1434</tr></tbody> 1435</table></div></td> 1436</tr> 1437<tr> 1438<td><p><span class="term">Postconditions:</span></p></td> 1439<td><p>if <code class="computeroutput">capacity().capacity() > 0</code> then <code class="computeroutput">back() == item</code><br> 1440 If the <code class="computeroutput"><a class="link" href="circular_idm46495624036048.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code> is full, the first element will be removed. If the capacity is <code class="computeroutput">0</code>, nothing will be inserted.<br> 1441<br> 1442 The amount of allocated memory in the internal buffer may be predictively increased. </p></td> 1443</tr> 1444<tr> 1445<td><p><span class="term">Throws:</span></p></td> 1446<td>An allocation error if memory is exhausted (<code class="computeroutput">std::bad_alloc</code> if the standard allocator is used). </td> 1447</tr> 1448</tbody> 1449</table></div> 1450</li> 1451<li class="listitem"> 1452<pre class="literallayout"><span class="keyword">void</span> <a name="idm46495623741472-bb"></a><span class="identifier">push_back</span><span class="special">(</span><span class="special">)</span><span class="special">;</span></pre>Insert a new element at the end of the space optimized circular buffer. <p> 1453 1454</p> 1455<p><b>Exception Safety. </b>Basic. </p> 1456<p> 1457</p> 1458<p><b>Iterator Invalidation. </b>Invalidates all iterators pointing to the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_idm46495624036048.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code> (except iterators equal to <code class="computeroutput">end()</code>). </p> 1459<p> 1460</p> 1461<p><b>Complexity. </b>Linear (in the size of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_idm46495624036048.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code>). </p> 1462<p> 1463</p> 1464<p><span class="bold"><strong>See Also:</strong></span></p> 1465<p><code class="computeroutput">push_front(const_reference)</code>, <code class="computeroutput">pop_back()</code>, <code class="computeroutput">pop_front()</code> </p> 1466<p> 1467</p> 1468<p> 1469</p> 1470<div class="variablelist"><table border="0" class="variablelist compact"> 1471<colgroup> 1472<col align="left" valign="top"> 1473<col> 1474</colgroup> 1475<tbody> 1476<tr> 1477<td><p><span class="term">Postconditions:</span></p></td> 1478<td><p>if <code class="computeroutput">capacity().capacity() > 0</code> then <code class="computeroutput">back() == item</code><br> 1479 If the <code class="computeroutput"><a class="link" href="circular_idm46495624036048.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code> is full, the first element will be removed. If the capacity is <code class="computeroutput">0</code>, nothing will be inserted.<br> 1480<br> 1481 The amount of allocated memory in the internal buffer may be predictively increased. </p></td> 1482</tr> 1483<tr> 1484<td><p><span class="term">Throws:</span></p></td> 1485<td>An allocation error if memory is exhausted (<code class="computeroutput">std::bad_alloc</code> if the standard allocator is used). Whatever <code class="computeroutput">T::T()</code> throws. Whatever <code class="computeroutput">T::T(const T&)</code> throws or nothing if <code class="computeroutput">T::T(T&&)</code> is noexcept. </td> 1486</tr> 1487</tbody> 1488</table></div> 1489</li> 1490<li class="listitem"> 1491<pre class="literallayout"><span class="keyword">void</span> <a name="idm46495623725824-bb"></a><span class="identifier">push_front</span><span class="special">(</span><span class="identifier">param_value_type</span> item<span class="special">)</span><span class="special">;</span></pre>Insert a new element at the beginning of the space optimized circular buffer. <p> 1492 1493 1494</p> 1495<p><b>Exception Safety. </b>Basic. </p> 1496<p> 1497</p> 1498<p><b>Iterator Invalidation. </b>Invalidates all iterators pointing to the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_idm46495624036048.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code> (except iterators equal to <code class="computeroutput">end()</code>). </p> 1499<p> 1500</p> 1501<p><b>Complexity. </b>Linear (in the size of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_idm46495624036048.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code>). </p> 1502<p> 1503</p> 1504<p><span class="bold"><strong>See Also:</strong></span></p> 1505<p><code class="computeroutput">push_back(const_reference)</code>, <code class="computeroutput">pop_back()</code>, <code class="computeroutput">pop_front()</code> </p> 1506<p> 1507</p> 1508<p> 1509</p> 1510<div class="variablelist"><table border="0" class="variablelist compact"> 1511<colgroup> 1512<col align="left" valign="top"> 1513<col> 1514</colgroup> 1515<tbody> 1516<tr> 1517<td><p><span class="term">Parameters:</span></p></td> 1518<td><div class="variablelist"><table border="0" class="variablelist compact"> 1519<colgroup> 1520<col align="left" valign="top"> 1521<col> 1522</colgroup> 1523<tbody><tr> 1524<td><p><span class="term"><code class="computeroutput">item</code></span></p></td> 1525<td><p>The element to be inserted. </p></td> 1526</tr></tbody> 1527</table></div></td> 1528</tr> 1529<tr> 1530<td><p><span class="term">Postconditions:</span></p></td> 1531<td><p>if <code class="computeroutput">capacity().capacity() > 0</code> then <code class="computeroutput">front() == item</code><br> 1532 If the <code class="computeroutput"><a class="link" href="circular_idm46495624036048.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code> is full, the last element will be removed. If the capacity is <code class="computeroutput">0</code>, nothing will be inserted.<br> 1533<br> 1534 The amount of allocated memory in the internal buffer may be predictively increased. </p></td> 1535</tr> 1536<tr> 1537<td><p><span class="term">Throws:</span></p></td> 1538<td>An allocation error if memory is exhausted (<code class="computeroutput">std::bad_alloc</code> if the standard allocator is used). Whatever <code class="computeroutput">T::T(const T&)</code> throws. </td> 1539</tr> 1540</tbody> 1541</table></div> 1542</li> 1543<li class="listitem"> 1544<pre class="literallayout"><span class="keyword">void</span> <a name="idm46495623709952-bb"></a><span class="identifier">push_front</span><span class="special">(</span><span class="identifier">rvalue_type</span> item<span class="special">)</span><span class="special">;</span></pre>Insert a new element at the beginning of the space optimized circular buffer. <p> 1545 1546 1547</p> 1548<p><b>Exception Safety. </b>Basic. </p> 1549<p> 1550</p> 1551<p><b>Iterator Invalidation. </b>Invalidates all iterators pointing to the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_idm46495624036048.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code> (except iterators equal to <code class="computeroutput">end()</code>). </p> 1552<p> 1553</p> 1554<p><b>Complexity. </b>Linear (in the size of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_idm46495624036048.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code>). </p> 1555<p> 1556</p> 1557<p><span class="bold"><strong>See Also:</strong></span></p> 1558<p><code class="computeroutput">push_back(const_reference)</code>, <code class="computeroutput">pop_back()</code>, <code class="computeroutput">pop_front()</code> </p> 1559<p> 1560</p> 1561<p> 1562</p> 1563<div class="variablelist"><table border="0" class="variablelist compact"> 1564<colgroup> 1565<col align="left" valign="top"> 1566<col> 1567</colgroup> 1568<tbody> 1569<tr> 1570<td><p><span class="term">Parameters:</span></p></td> 1571<td><div class="variablelist"><table border="0" class="variablelist compact"> 1572<colgroup> 1573<col align="left" valign="top"> 1574<col> 1575</colgroup> 1576<tbody><tr> 1577<td><p><span class="term"><code class="computeroutput">item</code></span></p></td> 1578<td><p>The element to be inserted. </p></td> 1579</tr></tbody> 1580</table></div></td> 1581</tr> 1582<tr> 1583<td><p><span class="term">Postconditions:</span></p></td> 1584<td><p>if <code class="computeroutput">capacity().capacity() > 0</code> then <code class="computeroutput">front() == item</code><br> 1585 If the <code class="computeroutput"><a class="link" href="circular_idm46495624036048.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code> is full, the last element will be removed. If the capacity is <code class="computeroutput">0</code>, nothing will be inserted.<br> 1586<br> 1587 The amount of allocated memory in the internal buffer may be predictively increased. </p></td> 1588</tr> 1589<tr> 1590<td><p><span class="term">Throws:</span></p></td> 1591<td>An allocation error if memory is exhausted (<code class="computeroutput">std::bad_alloc</code> if the standard allocator is used). Whatever <code class="computeroutput">T::T(const T&)</code> throws or nothing if <code class="computeroutput">T::T(T&&)</code> is noexcept. </td> 1592</tr> 1593</tbody> 1594</table></div> 1595</li> 1596<li class="listitem"> 1597<pre class="literallayout"><span class="keyword">void</span> <a name="idm46495623693632-bb"></a><span class="identifier">push_front</span><span class="special">(</span><span class="special">)</span><span class="special">;</span></pre>Insert a new element at the beginning of the space optimized circular buffer. <p> 1598 1599</p> 1600<p><b>Exception Safety. </b>Basic. </p> 1601<p> 1602</p> 1603<p><b>Iterator Invalidation. </b>Invalidates all iterators pointing to the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_idm46495624036048.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code> (except iterators equal to <code class="computeroutput">end()</code>). </p> 1604<p> 1605</p> 1606<p><b>Complexity. </b>Linear (in the size of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_idm46495624036048.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code>). </p> 1607<p> 1608</p> 1609<p><span class="bold"><strong>See Also:</strong></span></p> 1610<p><code class="computeroutput">push_back(const_reference)</code>, <code class="computeroutput">pop_back()</code>, <code class="computeroutput">pop_front()</code> </p> 1611<p> 1612</p> 1613<p> 1614</p> 1615<div class="variablelist"><table border="0" class="variablelist compact"> 1616<colgroup> 1617<col align="left" valign="top"> 1618<col> 1619</colgroup> 1620<tbody> 1621<tr> 1622<td><p><span class="term">Postconditions:</span></p></td> 1623<td><p>if <code class="computeroutput">capacity().capacity() > 0</code> then <code class="computeroutput">front() == item</code><br> 1624 If the <code class="computeroutput"><a class="link" href="circular_idm46495624036048.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code> is full, the last element will be removed. If the capacity is <code class="computeroutput">0</code>, nothing will be inserted.<br> 1625<br> 1626 The amount of allocated memory in the internal buffer may be predictively increased. </p></td> 1627</tr> 1628<tr> 1629<td><p><span class="term">Throws:</span></p></td> 1630<td>An allocation error if memory is exhausted (<code class="computeroutput">std::bad_alloc</code> if the standard allocator is used). Whatever <code class="computeroutput">T::T()</code> throws. Whatever <code class="computeroutput">T::T(const T&)</code> throws or nothing if <code class="computeroutput">T::T(T&&)</code> is noexcept. </td> 1631</tr> 1632</tbody> 1633</table></div> 1634</li> 1635<li class="listitem"> 1636<pre class="literallayout"><span class="keyword">void</span> <a name="idm46495623677984-bb"></a><span class="identifier">pop_back</span><span class="special">(</span><span class="special">)</span><span class="special">;</span></pre>Remove the last element from the space optimized circular buffer. <p> 1637 1638 1639</p> 1640<p><b>Exception Safety. </b>Basic. </p> 1641<p> 1642</p> 1643<p><b>Iterator Invalidation. </b>Invalidates all iterators pointing to the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_idm46495624036048.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code> (except iterators equal to <code class="computeroutput">end()</code>). </p> 1644<p> 1645</p> 1646<p><b>Complexity. </b>Linear (in the size of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_idm46495624036048.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code>). </p> 1647<p> 1648</p> 1649<p><span class="bold"><strong>See Also:</strong></span></p> 1650<p><code class="computeroutput">pop_front()</code>, <code class="computeroutput">push_back(const_reference)</code>, <code class="computeroutput">push_front(const_reference)</code> </p> 1651<p> 1652</p> 1653<p> 1654</p> 1655<div class="variablelist"><table border="0" class="variablelist compact"> 1656<colgroup> 1657<col align="left" valign="top"> 1658<col> 1659</colgroup> 1660<tbody> 1661<tr> 1662<td><p><span class="term">Requires:</span></p></td> 1663<td><p><code class="computeroutput">!empty()</code> </p></td> 1664</tr> 1665<tr> 1666<td><p><span class="term">Postconditions:</span></p></td> 1667<td><p>The last element is removed from the <code class="computeroutput"><a class="link" href="circular_idm46495624036048.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code>.<br> 1668<br> 1669 The amount of allocated memory in the internal buffer may be predictively decreased. </p></td> 1670</tr> 1671<tr> 1672<td><p><span class="term">Throws:</span></p></td> 1673<td>An allocation error if memory is exhausted (<code class="computeroutput">std::bad_alloc</code> if the standard allocator is used). </td> 1674</tr> 1675</tbody> 1676</table></div> 1677</li> 1678<li class="listitem"> 1679<pre class="literallayout"><span class="keyword">void</span> <a name="idm46495623664368-bb"></a><span class="identifier">pop_front</span><span class="special">(</span><span class="special">)</span><span class="special">;</span></pre>Remove the first element from the space optimized circular buffer. <p> 1680 1681 1682</p> 1683<p><b>Exception Safety. </b>Basic. </p> 1684<p> 1685</p> 1686<p><b>Iterator Invalidation. </b>Invalidates all iterators pointing to the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_idm46495624036048.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code> (except iterators equal to <code class="computeroutput">end()</code>). </p> 1687<p> 1688</p> 1689<p><b>Complexity. </b>Linear (in the size of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_idm46495624036048.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code>). </p> 1690<p> 1691</p> 1692<p><span class="bold"><strong>See Also:</strong></span></p> 1693<p><code class="computeroutput">pop_back()</code>, <code class="computeroutput">push_back(const_reference)</code>, <code class="computeroutput">push_front(const_reference)</code> </p> 1694<p> 1695</p> 1696<p> 1697</p> 1698<div class="variablelist"><table border="0" class="variablelist compact"> 1699<colgroup> 1700<col align="left" valign="top"> 1701<col> 1702</colgroup> 1703<tbody> 1704<tr> 1705<td><p><span class="term">Requires:</span></p></td> 1706<td><p><code class="computeroutput">!empty()</code> </p></td> 1707</tr> 1708<tr> 1709<td><p><span class="term">Postconditions:</span></p></td> 1710<td><p>The first element is removed from the <code class="computeroutput"><a class="link" href="circular_idm46495624036048.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code>.<br> 1711<br> 1712 The amount of allocated memory in the internal buffer may be predictively decreased. </p></td> 1713</tr> 1714<tr> 1715<td><p><span class="term">Throws:</span></p></td> 1716<td>An allocation error if memory is exhausted (<code class="computeroutput">std::bad_alloc</code> if the standard allocator is used). </td> 1717</tr> 1718</tbody> 1719</table></div> 1720</li> 1721<li class="listitem"> 1722<pre class="literallayout"><span class="identifier">iterator</span> <a name="idm46495623650752-bb"></a><span class="identifier">insert</span><span class="special">(</span><span class="identifier">iterator</span> pos<span class="special">,</span> <span class="identifier">param_value_type</span> item<span class="special">)</span><span class="special">;</span></pre>Insert an element at the specified position. <p> 1723 1724 1725 1726 1727</p> 1728<p><b>Exception Safety. </b>Basic. </p> 1729<p> 1730</p> 1731<p><b>Iterator Invalidation. </b>Invalidates all iterators pointing to the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_idm46495624036048.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code> (except iterators equal to <code class="computeroutput">end()</code>). </p> 1732<p> 1733</p> 1734<p><b>Complexity. </b>Linear (in the size of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_idm46495624036048.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code>). </p> 1735<p> 1736</p> 1737<p><span class="bold"><strong>See Also:</strong></span></p> 1738<p><code class="computeroutput">insert(iterator, size_type, value_type)</code>, <code class="computeroutput">insert(iterator, InputIterator, InputIterator)</code>, <code class="computeroutput">rinsert(iterator, value_type)</code>, <code class="computeroutput">rinsert(iterator, size_type, value_type)</code>, <code class="computeroutput">rinsert(iterator, InputIterator, InputIterator)</code> </p> 1739<p> 1740</p> 1741<p> 1742</p> 1743<div class="variablelist"><table border="0" class="variablelist compact"> 1744<colgroup> 1745<col align="left" valign="top"> 1746<col> 1747</colgroup> 1748<tbody> 1749<tr> 1750<td><p><span class="term">Parameters:</span></p></td> 1751<td><div class="variablelist"><table border="0" class="variablelist compact"> 1752<colgroup> 1753<col align="left" valign="top"> 1754<col> 1755</colgroup> 1756<tbody> 1757<tr> 1758<td><p><span class="term"><code class="computeroutput">item</code></span></p></td> 1759<td><p>The element to be inserted. </p></td> 1760</tr> 1761<tr> 1762<td><p><span class="term"><code class="computeroutput">pos</code></span></p></td> 1763<td><p>An iterator specifying the position where the <code class="computeroutput">item</code> will be inserted. </p></td> 1764</tr> 1765</tbody> 1766</table></div></td> 1767</tr> 1768<tr> 1769<td><p><span class="term">Requires:</span></p></td> 1770<td><p><code class="computeroutput">pos</code> is a valid iterator pointing to the <code class="computeroutput"><a class="link" href="circular_idm46495624036048.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code> or its end. </p></td> 1771</tr> 1772<tr> 1773<td><p><span class="term">Postconditions:</span></p></td> 1774<td><p>The <code class="computeroutput">item</code> will be inserted at the position <code class="computeroutput">pos</code>.<br> 1775 If the <code class="computeroutput"><a class="link" href="circular_idm46495624036048.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code> is full, the first element will be overwritten. If the <code class="computeroutput"><a class="link" href="circular_idm46495624036048.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code> is full and the <code class="computeroutput">pos</code> points to <code class="computeroutput">begin()</code>, then the <code class="computeroutput">item</code> will not be inserted. If the capacity is <code class="computeroutput">0</code>, nothing will be inserted.<br> 1776<br> 1777 The amount of allocated memory in the internal buffer may be predictively increased. </p></td> 1778</tr> 1779<tr> 1780<td><p><span class="term">Returns:</span></p></td> 1781<td><p>Iterator to the inserted element or <code class="computeroutput">begin()</code> if the <code class="computeroutput">item</code> is not inserted. (See the <span class="emphasis"><em>Effect</em></span>.) </p></td> 1782</tr> 1783<tr> 1784<td><p><span class="term">Throws:</span></p></td> 1785<td>An allocation error if memory is exhausted (<code class="computeroutput">std::bad_alloc</code> if the standard allocator is used). Whatever <code class="computeroutput">T::T(const T&)</code> throws. Whatever <code class="computeroutput">T::operator = (const T&)</code> throws. </td> 1786</tr> 1787</tbody> 1788</table></div> 1789</li> 1790<li class="listitem"> 1791<pre class="literallayout"><span class="identifier">iterator</span> <a name="idm46495623625728-bb"></a><span class="identifier">insert</span><span class="special">(</span><span class="identifier">iterator</span> pos<span class="special">,</span> <span class="identifier">rvalue_type</span> item<span class="special">)</span><span class="special">;</span></pre>Insert an element at the specified position. <p> 1792 1793 1794 1795 1796</p> 1797<p><b>Exception Safety. </b>Basic. </p> 1798<p> 1799</p> 1800<p><b>Iterator Invalidation. </b>Invalidates all iterators pointing to the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_idm46495624036048.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code> (except iterators equal to <code class="computeroutput">end()</code>). </p> 1801<p> 1802</p> 1803<p><b>Complexity. </b>Linear (in the size of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_idm46495624036048.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code>). </p> 1804<p> 1805</p> 1806<p><span class="bold"><strong>See Also:</strong></span></p> 1807<p><code class="computeroutput">insert(iterator, size_type, value_type)</code>, <code class="computeroutput">insert(iterator, InputIterator, InputIterator)</code>, <code class="computeroutput">rinsert(iterator, value_type)</code>, <code class="computeroutput">rinsert(iterator, size_type, value_type)</code>, <code class="computeroutput">rinsert(iterator, InputIterator, InputIterator)</code> </p> 1808<p> 1809</p> 1810<p> 1811</p> 1812<div class="variablelist"><table border="0" class="variablelist compact"> 1813<colgroup> 1814<col align="left" valign="top"> 1815<col> 1816</colgroup> 1817<tbody> 1818<tr> 1819<td><p><span class="term">Parameters:</span></p></td> 1820<td><div class="variablelist"><table border="0" class="variablelist compact"> 1821<colgroup> 1822<col align="left" valign="top"> 1823<col> 1824</colgroup> 1825<tbody> 1826<tr> 1827<td><p><span class="term"><code class="computeroutput">item</code></span></p></td> 1828<td><p>The element to be inserted. </p></td> 1829</tr> 1830<tr> 1831<td><p><span class="term"><code class="computeroutput">pos</code></span></p></td> 1832<td><p>An iterator specifying the position where the <code class="computeroutput">item</code> will be inserted. </p></td> 1833</tr> 1834</tbody> 1835</table></div></td> 1836</tr> 1837<tr> 1838<td><p><span class="term">Requires:</span></p></td> 1839<td><p><code class="computeroutput">pos</code> is a valid iterator pointing to the <code class="computeroutput"><a class="link" href="circular_idm46495624036048.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code> or its end. </p></td> 1840</tr> 1841<tr> 1842<td><p><span class="term">Postconditions:</span></p></td> 1843<td><p>The <code class="computeroutput">item</code> will be inserted at the position <code class="computeroutput">pos</code>.<br> 1844 If the <code class="computeroutput"><a class="link" href="circular_idm46495624036048.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code> is full, the first element will be overwritten. If the <code class="computeroutput"><a class="link" href="circular_idm46495624036048.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code> is full and the <code class="computeroutput">pos</code> points to <code class="computeroutput">begin()</code>, then the <code class="computeroutput">item</code> will not be inserted. If the capacity is <code class="computeroutput">0</code>, nothing will be inserted.<br> 1845<br> 1846 The amount of allocated memory in the internal buffer may be predictively increased. </p></td> 1847</tr> 1848<tr> 1849<td><p><span class="term">Returns:</span></p></td> 1850<td><p>Iterator to the inserted element or <code class="computeroutput">begin()</code> if the <code class="computeroutput">item</code> is not inserted. (See the <span class="emphasis"><em>Effect</em></span>.) </p></td> 1851</tr> 1852<tr> 1853<td><p><span class="term">Throws:</span></p></td> 1854<td>An allocation error if memory is exhausted (<code class="computeroutput">std::bad_alloc</code> if the standard allocator is used). Whatever <code class="computeroutput">T::T(const T&)</code> throws or nothing if <code class="computeroutput">T::T(T&&)</code> is noexcept. </td> 1855</tr> 1856</tbody> 1857</table></div> 1858</li> 1859<li class="listitem"> 1860<pre class="literallayout"><span class="identifier">iterator</span> <a name="idm46495623600720-bb"></a><span class="identifier">insert</span><span class="special">(</span><span class="identifier">iterator</span> pos<span class="special">)</span><span class="special">;</span></pre>Insert an element at the specified position. <p> 1861 1862 1863 1864 1865</p> 1866<p><b>Exception Safety. </b>Basic. </p> 1867<p> 1868</p> 1869<p><b>Iterator Invalidation. </b>Invalidates all iterators pointing to the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_idm46495624036048.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code> (except iterators equal to <code class="computeroutput">end()</code>). </p> 1870<p> 1871</p> 1872<p><b>Complexity. </b>Linear (in the size of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_idm46495624036048.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code>). </p> 1873<p> 1874</p> 1875<p><span class="bold"><strong>See Also:</strong></span></p> 1876<p><code class="computeroutput">insert(iterator, size_type, value_type)</code>, <code class="computeroutput">insert(iterator, InputIterator, InputIterator)</code>, <code class="computeroutput">rinsert(iterator, value_type)</code>, <code class="computeroutput">rinsert(iterator, size_type, value_type)</code>, <code class="computeroutput">rinsert(iterator, InputIterator, InputIterator)</code> </p> 1877<p> 1878</p> 1879<p> 1880</p> 1881<div class="variablelist"><table border="0" class="variablelist compact"> 1882<colgroup> 1883<col align="left" valign="top"> 1884<col> 1885</colgroup> 1886<tbody> 1887<tr> 1888<td><p><span class="term">Parameters:</span></p></td> 1889<td><div class="variablelist"><table border="0" class="variablelist compact"> 1890<colgroup> 1891<col align="left" valign="top"> 1892<col> 1893</colgroup> 1894<tbody><tr> 1895<td><p><span class="term"><code class="computeroutput">pos</code></span></p></td> 1896<td><p>An iterator specifying the position where the <code class="computeroutput">item</code> will be inserted. </p></td> 1897</tr></tbody> 1898</table></div></td> 1899</tr> 1900<tr> 1901<td><p><span class="term">Requires:</span></p></td> 1902<td><p><code class="computeroutput">pos</code> is a valid iterator pointing to the <code class="computeroutput"><a class="link" href="circular_idm46495624036048.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code> or its end. </p></td> 1903</tr> 1904<tr> 1905<td><p><span class="term">Postconditions:</span></p></td> 1906<td><p>The <code class="computeroutput">item</code> will be inserted at the position <code class="computeroutput">pos</code>.<br> 1907 If the <code class="computeroutput"><a class="link" href="circular_idm46495624036048.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code> is full, the first element will be overwritten. If the <code class="computeroutput"><a class="link" href="circular_idm46495624036048.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code> is full and the <code class="computeroutput">pos</code> points to <code class="computeroutput">begin()</code>, then the <code class="computeroutput">item</code> will not be inserted. If the capacity is <code class="computeroutput">0</code>, nothing will be inserted.<br> 1908<br> 1909 The amount of allocated memory in the internal buffer may be predictively increased. </p></td> 1910</tr> 1911<tr> 1912<td><p><span class="term">Returns:</span></p></td> 1913<td><p>Iterator to the inserted element or <code class="computeroutput">begin()</code> if the <code class="computeroutput">item</code> is not inserted. (See the <span class="emphasis"><em>Effect</em></span>.) </p></td> 1914</tr> 1915<tr> 1916<td><p><span class="term">Throws:</span></p></td> 1917<td>An allocation error if memory is exhausted (<code class="computeroutput">std::bad_alloc</code> if the standard allocator is used). Whatever <code class="computeroutput">T::T()</code> throws. Whatever <code class="computeroutput">T::T(const T&)</code> throws or nothing if <code class="computeroutput">T::T(T&&)</code> is noexcept. </td> 1918</tr> 1919</tbody> 1920</table></div> 1921</li> 1922<li class="listitem"> 1923<pre class="literallayout"><span class="keyword">void</span> <a name="idm46495623576384-bb"></a><span class="identifier">insert</span><span class="special">(</span><span class="identifier">iterator</span> pos<span class="special">,</span> <span class="identifier">size_type</span> n<span class="special">,</span> <span class="identifier">param_value_type</span> item<span class="special">)</span><span class="special">;</span></pre>Insert <code class="computeroutput">n</code> copies of the <code class="computeroutput">item</code> at the specified position. <p> 1924 1925 1926 1927</p> 1928<p><b>Exception Safety. </b>Basic. </p> 1929<p> 1930</p> 1931<p><b>Iterator Invalidation. </b>Invalidates all iterators pointing to the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_idm46495624036048.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code> (except iterators equal to <code class="computeroutput">end()</code>). </p> 1932<p> 1933</p> 1934<p><b>Complexity. </b>Linear (in <code class="computeroutput">min[capacity().capacity(), size() + n]</code>). </p> 1935<p> 1936</p> 1937<p><b>Example. </b>Consider a <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_idm46495624036048.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code> with the capacity of 6 and the size of 4. Its internal buffer may look like the one below.<br> 1938<br> 1939 <code class="computeroutput">|1|2|3|4| | |</code><br> 1940 <code class="computeroutput">p ___^</code><br> 1941<br> 1942After inserting 5 elements at the position <code class="computeroutput">p</code>:<br> 1943<br> 1944 <code class="computeroutput">insert(p, (size_t)5, 0);</code><br> 1945<br> 1946actually only 4 elements get inserted and elements <code class="computeroutput">1</code> and <code class="computeroutput">2</code> are overwritten. This is due to the fact the insert operation preserves the capacity. After insertion the internal buffer looks like this:<br> 1947<br> 1948<code class="computeroutput">|0|0|0|0|3|4|</code><br> 1949 <br> 1950For comparison if the capacity would not be preserved the internal buffer would then result in <code class="computeroutput">|1|2|0|0|0|0|0|3|4|</code>. </p> 1951<p> 1952</p> 1953<p><span class="bold"><strong>See Also:</strong></span></p> 1954<p><code class="computeroutput">insert(iterator, value_type)</code>, <code class="computeroutput">insert(iterator, InputIterator, InputIterator)</code>, <code class="computeroutput">rinsert(iterator, value_type)</code>, <code class="computeroutput">rinsert(iterator, size_type, value_type)</code>, <code class="computeroutput">rinsert(iterator, InputIterator, InputIterator)</code> </p> 1955<p> 1956</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">Parameters:</span></p></td> 1967<td><div class="variablelist"><table border="0" class="variablelist compact"> 1968<colgroup> 1969<col align="left" valign="top"> 1970<col> 1971</colgroup> 1972<tbody> 1973<tr> 1974<td><p><span class="term"><code class="computeroutput">item</code></span></p></td> 1975<td><p>The element whose copies will be inserted. </p></td> 1976</tr> 1977<tr> 1978<td><p><span class="term"><code class="computeroutput">n</code></span></p></td> 1979<td><p>The number of <code class="computeroutput">item</code>s the to be inserted. </p></td> 1980</tr> 1981<tr> 1982<td><p><span class="term"><code class="computeroutput">pos</code></span></p></td> 1983<td><p>An iterator specifying the position where the <code class="computeroutput">item</code>s will be inserted. </p></td> 1984</tr> 1985</tbody> 1986</table></div></td> 1987</tr> 1988<tr> 1989<td><p><span class="term">Requires:</span></p></td> 1990<td><p><code class="computeroutput">pos</code> is a valid iterator pointing to the <code class="computeroutput"><a class="link" href="circular_idm46495624036048.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code> or its end. </p></td> 1991</tr> 1992<tr> 1993<td><p><span class="term">Postconditions:</span></p></td> 1994<td><p>The number of <code class="computeroutput">min[n, (pos - begin()) + reserve()]</code> elements will be inserted at the position <code class="computeroutput">pos</code>.<br> 1995The number of <code class="computeroutput">min[pos - begin(), max[0, n - reserve()]]</code> elements will be overwritten at the beginning of the <code class="computeroutput"><a class="link" href="circular_idm46495624036048.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code>.<br> 1996(See <span class="emphasis"><em>Example</em></span> for the explanation.)<br> 1997<br> 1998 The amount of allocated memory in the internal buffer may be predictively increased. </p></td> 1999</tr> 2000<tr> 2001<td><p><span class="term">Throws:</span></p></td> 2002<td>An allocation error if memory is exhausted (<code class="computeroutput">std::bad_alloc</code> if the standard allocator is used). Whatever <code class="computeroutput">T::T(const T&)</code> throws. Whatever <code class="computeroutput">T::operator = (const T&)</code> throws. </td> 2003</tr> 2004</tbody> 2005</table></div> 2006</li> 2007<li class="listitem"> 2008<pre class="literallayout"><span class="keyword">template</span><span class="special"><</span><span class="keyword">typename</span> InputIterator<span class="special">></span> 2009 <span class="keyword">void</span> <a name="idm46495623543824-bb"></a><span class="identifier">insert</span><span class="special">(</span><span class="identifier">iterator</span> pos<span class="special">,</span> <span class="identifier">InputIterator</span> first<span class="special">,</span> <span class="identifier">InputIterator</span> last<span class="special">)</span><span class="special">;</span></pre>Insert the range <code class="computeroutput">[first, last)</code> at the specified position. <p> 2010 2011 2012 2013</p> 2014<p><b>Exception Safety. </b>Basic. </p> 2015<p> 2016</p> 2017<p><b>Iterator Invalidation. </b>Invalidates all iterators pointing to the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_idm46495624036048.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code> (except iterators equal to <code class="computeroutput">end()</code>). </p> 2018<p> 2019</p> 2020<p><b>Complexity. </b>Linear (in <code class="computeroutput">[size() + std::distance(first, last)]</code>; in <code class="computeroutput">min[capacity().capacity(), size() + std::distance(first, last)]</code> if the <code class="computeroutput">InputIterator</code> is a <a href="https://www.boost.org/sgi/stl/RandomAccessIterator.html" target="_top">RandomAccessIterator</a>). </p> 2021<p> 2022</p> 2023<p><b>Example. </b>Consider a <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_idm46495624036048.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code> with the capacity of 6 and the size of 4. Its internal buffer may look like the one below.<br> 2024<br> 2025 <code class="computeroutput">|1|2|3|4| | |</code><br> 2026 <code class="computeroutput">p ___^</code><br> 2027<br> 2028After inserting a range of elements at the position <code class="computeroutput">p</code>:<br> 2029<br> 2030 <code class="computeroutput">int array[] = { 5, 6, 7, 8, 9 };</code><br> 2031<code class="computeroutput">insert(p, array, array + 5);</code><br> 2032<br> 2033 actually only elements <code class="computeroutput">6</code>, <code class="computeroutput">7</code>, <code class="computeroutput">8</code> and <code class="computeroutput">9</code> from the specified range get inserted and elements <code class="computeroutput">1</code> and <code class="computeroutput">2</code> are overwritten. This is due to the fact the insert operation preserves the capacity. After insertion the internal buffer looks like this:<br> 2034<br> 2035<code class="computeroutput">|6|7|8|9|3|4|</code><br> 2036<br> 2037For comparison if the capacity would not be preserved the internal buffer would then result in <code class="computeroutput">|1|2|5|6|7|8|9|3|4|</code>. </p> 2038<p> 2039</p> 2040<p><span class="bold"><strong>See Also:</strong></span></p> 2041<p><code class="computeroutput">insert(iterator, value_type)</code>, <code class="computeroutput">insert(iterator, size_type, value_type)</code>, <code class="computeroutput">rinsert(iterator, value_type)</code>, <code class="computeroutput">rinsert(iterator, size_type, value_type)</code>, <code class="computeroutput">rinsert(iterator, InputIterator, InputIterator)</code> </p> 2042<p> 2043</p> 2044<p> 2045</p> 2046<div class="variablelist"><table border="0" class="variablelist compact"> 2047<colgroup> 2048<col align="left" valign="top"> 2049<col> 2050</colgroup> 2051<tbody> 2052<tr> 2053<td><p><span class="term">Parameters:</span></p></td> 2054<td><div class="variablelist"><table border="0" class="variablelist compact"> 2055<colgroup> 2056<col align="left" valign="top"> 2057<col> 2058</colgroup> 2059<tbody> 2060<tr> 2061<td><p><span class="term"><code class="computeroutput">first</code></span></p></td> 2062<td><p>The beginning of the range to be inserted. </p></td> 2063</tr> 2064<tr> 2065<td><p><span class="term"><code class="computeroutput">last</code></span></p></td> 2066<td><p>The end of the range to be inserted. </p></td> 2067</tr> 2068<tr> 2069<td><p><span class="term"><code class="computeroutput">pos</code></span></p></td> 2070<td><p>An iterator specifying the position where the range will be inserted. </p></td> 2071</tr> 2072</tbody> 2073</table></div></td> 2074</tr> 2075<tr> 2076<td><p><span class="term">Requires:</span></p></td> 2077<td><p><code class="computeroutput">pos</code> is a valid iterator pointing to the <code class="computeroutput"><a class="link" href="circular_idm46495624036048.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code> or its end.<br> 2078Valid range <code class="computeroutput">[first, last)</code> where <code class="computeroutput">first</code> and <code class="computeroutput">last</code> meet the requirements of an <a href="https://www.boost.org/sgi/stl/InputIterator.html" target="_top">InputIterator</a>. </p></td> 2079</tr> 2080<tr> 2081<td><p><span class="term">Postconditions:</span></p></td> 2082<td><p>Elements from the range <code class="computeroutput">[first + max[0, distance(first, last) - (pos - begin()) - reserve()], last)</code> will be inserted at the position <code class="computeroutput">pos</code>.<br> 2083The number of <code class="computeroutput">min[pos - begin(), max[0, distance(first, last) - reserve()]]</code> elements will be overwritten at the beginning of the <code class="computeroutput"><a class="link" href="circular_idm46495624036048.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code>.<br> 2084(See <span class="emphasis"><em>Example</em></span> for the explanation.)<br> 2085<br> 2086 The amount of allocated memory in the internal buffer may be predictively increased. </p></td> 2087</tr> 2088<tr> 2089<td><p><span class="term">Throws:</span></p></td> 2090<td>An allocation error if memory is exhausted (<code class="computeroutput">std::bad_alloc</code> if the standard allocator is used). Whatever <code class="computeroutput">T::T(const T&)</code> throws or nothing if <code class="computeroutput">T::T(T&&)</code> is noexcept. </td> 2091</tr> 2092</tbody> 2093</table></div> 2094</li> 2095<li class="listitem"> 2096<pre class="literallayout"><span class="identifier">iterator</span> <a name="idm46495623505200-bb"></a><span class="identifier">rinsert</span><span class="special">(</span><span class="identifier">iterator</span> pos<span class="special">,</span> <span class="identifier">param_value_type</span> item<span class="special">)</span><span class="special">;</span></pre>Insert an element before the specified position. <p> 2097 2098 2099 2100 2101</p> 2102<p><b>Exception Safety. </b>Basic. </p> 2103<p> 2104</p> 2105<p><b>Iterator Invalidation. </b>Invalidates all iterators pointing to the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_idm46495624036048.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code> (except iterators equal to <code class="computeroutput">end()</code>). </p> 2106<p> 2107</p> 2108<p><b>Complexity. </b>Linear (in the size of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_idm46495624036048.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code>). </p> 2109<p> 2110</p> 2111<p><span class="bold"><strong>See Also:</strong></span></p> 2112<p><code class="computeroutput">rinsert(iterator, size_type, value_type)</code>, <code class="computeroutput">rinsert(iterator, InputIterator, InputIterator)</code>, <code class="computeroutput">insert(iterator, value_type)</code>, <code class="computeroutput">insert(iterator, size_type, value_type)</code>, <code class="computeroutput">insert(iterator, InputIterator, InputIterator)</code> </p> 2113<p> 2114</p> 2115<p> 2116</p> 2117<div class="variablelist"><table border="0" class="variablelist compact"> 2118<colgroup> 2119<col align="left" valign="top"> 2120<col> 2121</colgroup> 2122<tbody> 2123<tr> 2124<td><p><span class="term">Parameters:</span></p></td> 2125<td><div class="variablelist"><table border="0" class="variablelist compact"> 2126<colgroup> 2127<col align="left" valign="top"> 2128<col> 2129</colgroup> 2130<tbody> 2131<tr> 2132<td><p><span class="term"><code class="computeroutput">item</code></span></p></td> 2133<td><p>The element to be inserted. </p></td> 2134</tr> 2135<tr> 2136<td><p><span class="term"><code class="computeroutput">pos</code></span></p></td> 2137<td><p>An iterator specifying the position before which the <code class="computeroutput">item</code> will be inserted. </p></td> 2138</tr> 2139</tbody> 2140</table></div></td> 2141</tr> 2142<tr> 2143<td><p><span class="term">Requires:</span></p></td> 2144<td><p><code class="computeroutput">pos</code> is a valid iterator pointing to the <code class="computeroutput"><a class="link" href="circular_idm46495624036048.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code> or its end. </p></td> 2145</tr> 2146<tr> 2147<td><p><span class="term">Postconditions:</span></p></td> 2148<td><p>The <code class="computeroutput">item</code> will be inserted before the position <code class="computeroutput">pos</code>.<br> 2149 If the <code class="computeroutput"><a class="link" href="circular_idm46495624036048.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code> is full, the last element will be overwritten. If the <code class="computeroutput"><a class="link" href="circular_idm46495624036048.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code> is full and the <code class="computeroutput">pos</code> points to <code class="computeroutput">end()</code>, then the <code class="computeroutput">item</code> will not be inserted. If the capacity is <code class="computeroutput">0</code>, nothing will be inserted.<br> 2150<br> 2151 The amount of allocated memory in the internal buffer may be predictively increased. </p></td> 2152</tr> 2153<tr> 2154<td><p><span class="term">Returns:</span></p></td> 2155<td><p>Iterator to the inserted element or <code class="computeroutput">end()</code> if the <code class="computeroutput">item</code> is not inserted. (See the <span class="emphasis"><em>Effect</em></span>.) </p></td> 2156</tr> 2157<tr> 2158<td><p><span class="term">Throws:</span></p></td> 2159<td>An allocation error if memory is exhausted (<code class="computeroutput">std::bad_alloc</code> if the standard allocator is used). Whatever <code class="computeroutput">T::T(const T&)</code> throws. Whatever <code class="computeroutput">T::operator = (const T&)</code> throws. </td> 2160</tr> 2161</tbody> 2162</table></div> 2163</li> 2164<li class="listitem"> 2165<pre class="literallayout"><span class="identifier">iterator</span> <a name="idm46495623480192-bb"></a><span class="identifier">rinsert</span><span class="special">(</span><span class="identifier">iterator</span> pos<span class="special">,</span> <span class="identifier">rvalue_type</span> item<span class="special">)</span><span class="special">;</span></pre>Insert an element before the specified position. <p> 2166 2167 2168 2169 2170</p> 2171<p><b>Exception Safety. </b>Basic. </p> 2172<p> 2173</p> 2174<p><b>Iterator Invalidation. </b>Invalidates all iterators pointing to the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_idm46495624036048.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code> (except iterators equal to <code class="computeroutput">end()</code>). </p> 2175<p> 2176</p> 2177<p><b>Complexity. </b>Linear (in the size of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_idm46495624036048.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code>). </p> 2178<p> 2179</p> 2180<p><span class="bold"><strong>See Also:</strong></span></p> 2181<p><code class="computeroutput">rinsert(iterator, size_type, value_type)</code>, <code class="computeroutput">rinsert(iterator, InputIterator, InputIterator)</code>, <code class="computeroutput">insert(iterator, value_type)</code>, <code class="computeroutput">insert(iterator, size_type, value_type)</code>, <code class="computeroutput">insert(iterator, InputIterator, InputIterator)</code> </p> 2182<p> 2183</p> 2184<p> 2185</p> 2186<div class="variablelist"><table border="0" class="variablelist compact"> 2187<colgroup> 2188<col align="left" valign="top"> 2189<col> 2190</colgroup> 2191<tbody> 2192<tr> 2193<td><p><span class="term">Parameters:</span></p></td> 2194<td><div class="variablelist"><table border="0" class="variablelist compact"> 2195<colgroup> 2196<col align="left" valign="top"> 2197<col> 2198</colgroup> 2199<tbody> 2200<tr> 2201<td><p><span class="term"><code class="computeroutput">item</code></span></p></td> 2202<td><p>The element to be inserted. </p></td> 2203</tr> 2204<tr> 2205<td><p><span class="term"><code class="computeroutput">pos</code></span></p></td> 2206<td><p>An iterator specifying the position before which the <code class="computeroutput">item</code> will be inserted. </p></td> 2207</tr> 2208</tbody> 2209</table></div></td> 2210</tr> 2211<tr> 2212<td><p><span class="term">Requires:</span></p></td> 2213<td><p><code class="computeroutput">pos</code> is a valid iterator pointing to the <code class="computeroutput"><a class="link" href="circular_idm46495624036048.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code> or its end. </p></td> 2214</tr> 2215<tr> 2216<td><p><span class="term">Postconditions:</span></p></td> 2217<td><p>The <code class="computeroutput">item</code> will be inserted before the position <code class="computeroutput">pos</code>.<br> 2218 If the <code class="computeroutput"><a class="link" href="circular_idm46495624036048.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code> is full, the last element will be overwritten. If the <code class="computeroutput"><a class="link" href="circular_idm46495624036048.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code> is full and the <code class="computeroutput">pos</code> points to <code class="computeroutput">end()</code>, then the <code class="computeroutput">item</code> will not be inserted. If the capacity is <code class="computeroutput">0</code>, nothing will be inserted.<br> 2219<br> 2220 The amount of allocated memory in the internal buffer may be predictively increased. </p></td> 2221</tr> 2222<tr> 2223<td><p><span class="term">Returns:</span></p></td> 2224<td><p>Iterator to the inserted element or <code class="computeroutput">end()</code> if the <code class="computeroutput">item</code> is not inserted. (See the <span class="emphasis"><em>Effect</em></span>.) </p></td> 2225</tr> 2226<tr> 2227<td><p><span class="term">Throws:</span></p></td> 2228<td>An allocation error if memory is exhausted (<code class="computeroutput">std::bad_alloc</code> if the standard allocator is used). Whatever <code class="computeroutput">T::T(const T&)</code> throws or nothing if <code class="computeroutput">T::T(T&&)</code> is noexcept. </td> 2229</tr> 2230</tbody> 2231</table></div> 2232</li> 2233<li class="listitem"> 2234<pre class="literallayout"><span class="identifier">iterator</span> <a name="idm46495623455200-bb"></a><span class="identifier">rinsert</span><span class="special">(</span><span class="identifier">iterator</span> pos<span class="special">)</span><span class="special">;</span></pre>Insert an element before the specified position. <p> 2235 2236 2237 2238 2239</p> 2240<p><b>Exception Safety. </b>Basic. </p> 2241<p> 2242</p> 2243<p><b>Iterator Invalidation. </b>Invalidates all iterators pointing to the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_idm46495624036048.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code> (except iterators equal to <code class="computeroutput">end()</code>). </p> 2244<p> 2245</p> 2246<p><b>Complexity. </b>Linear (in the size of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_idm46495624036048.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code>). </p> 2247<p> 2248</p> 2249<p><span class="bold"><strong>See Also:</strong></span></p> 2250<p><code class="computeroutput">rinsert(iterator, size_type, value_type)</code>, <code class="computeroutput">rinsert(iterator, InputIterator, InputIterator)</code>, <code class="computeroutput">insert(iterator, value_type)</code>, <code class="computeroutput">insert(iterator, size_type, value_type)</code>, <code class="computeroutput">insert(iterator, InputIterator, InputIterator)</code> </p> 2251<p> 2252</p> 2253<p> 2254</p> 2255<div class="variablelist"><table border="0" class="variablelist compact"> 2256<colgroup> 2257<col align="left" valign="top"> 2258<col> 2259</colgroup> 2260<tbody> 2261<tr> 2262<td><p><span class="term">Parameters:</span></p></td> 2263<td><div class="variablelist"><table border="0" class="variablelist compact"> 2264<colgroup> 2265<col align="left" valign="top"> 2266<col> 2267</colgroup> 2268<tbody><tr> 2269<td><p><span class="term"><code class="computeroutput">pos</code></span></p></td> 2270<td><p>An iterator specifying the position before which the <code class="computeroutput">item</code> will be inserted. </p></td> 2271</tr></tbody> 2272</table></div></td> 2273</tr> 2274<tr> 2275<td><p><span class="term">Requires:</span></p></td> 2276<td><p><code class="computeroutput">pos</code> is a valid iterator pointing to the <code class="computeroutput"><a class="link" href="circular_idm46495624036048.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code> or its end. </p></td> 2277</tr> 2278<tr> 2279<td><p><span class="term">Postconditions:</span></p></td> 2280<td><p>The <code class="computeroutput">item</code> will be inserted before the position <code class="computeroutput">pos</code>.<br> 2281 If the <code class="computeroutput"><a class="link" href="circular_idm46495624036048.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code> is full, the last element will be overwritten. If the <code class="computeroutput"><a class="link" href="circular_idm46495624036048.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code> is full and the <code class="computeroutput">pos</code> points to <code class="computeroutput">end()</code>, then the <code class="computeroutput">item</code> will not be inserted. If the capacity is <code class="computeroutput">0</code>, nothing will be inserted.<br> 2282<br> 2283 The amount of allocated memory in the internal buffer may be predictively increased. </p></td> 2284</tr> 2285<tr> 2286<td><p><span class="term">Returns:</span></p></td> 2287<td><p>Iterator to the inserted element or <code class="computeroutput">end()</code> if the <code class="computeroutput">item</code> is not inserted. (See the <span class="emphasis"><em>Effect</em></span>.) </p></td> 2288</tr> 2289<tr> 2290<td><p><span class="term">Throws:</span></p></td> 2291<td>An allocation error if memory is exhausted (<code class="computeroutput">std::bad_alloc</code> if the standard allocator is used). Whatever <code class="computeroutput">T::T()</code> throws. Whatever <code class="computeroutput">T::T(const T&)</code> throws or nothing if <code class="computeroutput">T::T(T&&)</code> is noexcept. </td> 2292</tr> 2293</tbody> 2294</table></div> 2295</li> 2296<li class="listitem"> 2297<pre class="literallayout"><span class="keyword">void</span> <a name="idm46495623430880-bb"></a><span class="identifier">rinsert</span><span class="special">(</span><span class="identifier">iterator</span> pos<span class="special">,</span> <span class="identifier">size_type</span> n<span class="special">,</span> <span class="identifier">param_value_type</span> item<span class="special">)</span><span class="special">;</span></pre>Insert <code class="computeroutput">n</code> copies of the <code class="computeroutput">item</code> before the specified position. <p> 2298 2299 2300 2301</p> 2302<p><b>Exception Safety. </b>Basic. </p> 2303<p> 2304</p> 2305<p><b>Iterator Invalidation. </b>Invalidates all iterators pointing to the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_idm46495624036048.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code> (except iterators equal to <code class="computeroutput">end()</code>). </p> 2306<p> 2307</p> 2308<p><b>Complexity. </b>Linear (in <code class="computeroutput">min[capacity().capacity(), size() + n]</code>). </p> 2309<p> 2310</p> 2311<p><b>Example. </b>Consider a <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_idm46495624036048.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code> with the capacity of 6 and the size of 4. Its internal buffer may look like the one below.<br> 2312<br> 2313 <code class="computeroutput">|1|2|3|4| | |</code><br> 2314 <code class="computeroutput">p ___^</code><br> 2315<br> 2316After inserting 5 elements before the position <code class="computeroutput">p</code>:<br> 2317<br> 2318 <code class="computeroutput">rinsert(p, (size_t)5, 0);</code><br> 2319<br> 2320actually only 4 elements get inserted and elements <code class="computeroutput">3</code> and <code class="computeroutput">4</code> are overwritten. This is due to the fact the rinsert operation preserves the capacity. After insertion the internal buffer looks like this:<br> 2321<br> 2322<code class="computeroutput">|1|2|0|0|0|0|</code><br> 2323 <br> 2324For comparison if the capacity would not be preserved the internal buffer would then result in <code class="computeroutput">|1|2|0|0|0|0|0|3|4|</code>. </p> 2325<p> 2326</p> 2327<p><span class="bold"><strong>See Also:</strong></span></p> 2328<p><code class="computeroutput">rinsert(iterator, value_type)</code>, <code class="computeroutput">rinsert(iterator, InputIterator, InputIterator)</code>, <code class="computeroutput">insert(iterator, value_type)</code>, <code class="computeroutput">insert(iterator, size_type, value_type)</code>, <code class="computeroutput">insert(iterator, InputIterator, InputIterator)</code> </p> 2329<p> 2330</p> 2331<p> 2332</p> 2333<div class="variablelist"><table border="0" class="variablelist compact"> 2334<colgroup> 2335<col align="left" valign="top"> 2336<col> 2337</colgroup> 2338<tbody> 2339<tr> 2340<td><p><span class="term">Parameters:</span></p></td> 2341<td><div class="variablelist"><table border="0" class="variablelist compact"> 2342<colgroup> 2343<col align="left" valign="top"> 2344<col> 2345</colgroup> 2346<tbody> 2347<tr> 2348<td><p><span class="term"><code class="computeroutput">item</code></span></p></td> 2349<td><p>The element whose copies will be inserted. </p></td> 2350</tr> 2351<tr> 2352<td><p><span class="term"><code class="computeroutput">n</code></span></p></td> 2353<td><p>The number of <code class="computeroutput">item</code>s the to be inserted. </p></td> 2354</tr> 2355<tr> 2356<td><p><span class="term"><code class="computeroutput">pos</code></span></p></td> 2357<td><p>An iterator specifying the position where the <code class="computeroutput">item</code>s will be inserted. </p></td> 2358</tr> 2359</tbody> 2360</table></div></td> 2361</tr> 2362<tr> 2363<td><p><span class="term">Requires:</span></p></td> 2364<td><p><code class="computeroutput">pos</code> is a valid iterator pointing to the <code class="computeroutput"><a class="link" href="circular_idm46495624036048.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code> or its end. </p></td> 2365</tr> 2366<tr> 2367<td><p><span class="term">Postconditions:</span></p></td> 2368<td><p>The number of <code class="computeroutput">min[n, (end() - pos) + reserve()]</code> elements will be inserted before the position <code class="computeroutput">pos</code>.<br> 2369The number of <code class="computeroutput">min[end() - pos, max[0, n - reserve()]]</code> elements will be overwritten at the end of the <code class="computeroutput"><a class="link" href="circular_idm46495624036048.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code>.<br> 2370(See <span class="emphasis"><em>Example</em></span> for the explanation.)<br> 2371<br> 2372 The amount of allocated memory in the internal buffer may be predictively increased. </p></td> 2373</tr> 2374<tr> 2375<td><p><span class="term">Throws:</span></p></td> 2376<td>An allocation error if memory is exhausted (<code class="computeroutput">std::bad_alloc</code> if the standard allocator is used). Whatever <code class="computeroutput">T::T(const T&)</code> throws. Whatever <code class="computeroutput">T::operator = (const T&)</code> throws. </td> 2377</tr> 2378</tbody> 2379</table></div> 2380</li> 2381<li class="listitem"> 2382<pre class="literallayout"><span class="keyword">template</span><span class="special"><</span><span class="keyword">typename</span> InputIterator<span class="special">></span> 2383 <span class="keyword">void</span> <a name="idm46495623398352-bb"></a><span class="identifier">rinsert</span><span class="special">(</span><span class="identifier">iterator</span> pos<span class="special">,</span> <span class="identifier">InputIterator</span> first<span class="special">,</span> <span class="identifier">InputIterator</span> last<span class="special">)</span><span class="special">;</span></pre>Insert the range <code class="computeroutput">[first, last)</code> before the specified position. <p> 2384 2385 2386 2387</p> 2388<p><b>Exception Safety. </b>Basic. </p> 2389<p> 2390</p> 2391<p><b>Iterator Invalidation. </b>Invalidates all iterators pointing to the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_idm46495624036048.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code> (except iterators equal to <code class="computeroutput">end()</code>). </p> 2392<p> 2393</p> 2394<p><b>Complexity. </b>Linear (in <code class="computeroutput">[size() + std::distance(first, last)]</code>; in <code class="computeroutput">min[capacity().capacity(), size() + std::distance(first, last)]</code> if the <code class="computeroutput">InputIterator</code> is a <a href="https://www.boost.org/sgi/stl/RandomAccessIterator.html" target="_top">RandomAccessIterator</a>). </p> 2395<p> 2396</p> 2397<p><b>Example. </b>Consider a <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_idm46495624036048.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code> with the capacity of 6 and the size of 4. Its internal buffer may look like the one below.<br> 2398<br> 2399 <code class="computeroutput">|1|2|3|4| | |</code><br> 2400 <code class="computeroutput">p ___^</code><br> 2401<br> 2402After inserting a range of elements before the position <code class="computeroutput">p</code>:<br> 2403<br> 2404 <code class="computeroutput">int array[] = { 5, 6, 7, 8, 9 };</code><br> 2405<code class="computeroutput">insert(p, array, array + 5);</code><br> 2406<br> 2407 actually only elements <code class="computeroutput">5</code>, <code class="computeroutput">6</code>, <code class="computeroutput">7</code> and <code class="computeroutput">8</code> from the specified range get inserted and elements <code class="computeroutput">3</code> and <code class="computeroutput">4</code> are overwritten. This is due to the fact the rinsert operation preserves the capacity. After insertion the internal buffer looks like this:<br> 2408<br> 2409<code class="computeroutput">|1|2|5|6|7|8|</code><br> 2410<br> 2411For comparison if the capacity would not be preserved the internal buffer would then result in <code class="computeroutput">|1|2|5|6|7|8|9|3|4|</code>. </p> 2412<p> 2413</p> 2414<p><span class="bold"><strong>See Also:</strong></span></p> 2415<p><code class="computeroutput">rinsert(iterator, value_type)</code>, <code class="computeroutput">rinsert(iterator, size_type, value_type)</code>, <code class="computeroutput">insert(iterator, value_type)</code>, <code class="computeroutput">insert(iterator, size_type, value_type)</code>, <code class="computeroutput">insert(iterator, InputIterator, InputIterator)</code> </p> 2416<p> 2417</p> 2418<p> 2419</p> 2420<div class="variablelist"><table border="0" class="variablelist compact"> 2421<colgroup> 2422<col align="left" valign="top"> 2423<col> 2424</colgroup> 2425<tbody> 2426<tr> 2427<td><p><span class="term">Parameters:</span></p></td> 2428<td><div class="variablelist"><table border="0" class="variablelist compact"> 2429<colgroup> 2430<col align="left" valign="top"> 2431<col> 2432</colgroup> 2433<tbody> 2434<tr> 2435<td><p><span class="term"><code class="computeroutput">first</code></span></p></td> 2436<td><p>The beginning of the range to be inserted. </p></td> 2437</tr> 2438<tr> 2439<td><p><span class="term"><code class="computeroutput">last</code></span></p></td> 2440<td><p>The end of the range to be inserted. </p></td> 2441</tr> 2442<tr> 2443<td><p><span class="term"><code class="computeroutput">pos</code></span></p></td> 2444<td><p>An iterator specifying the position where the range will be inserted. </p></td> 2445</tr> 2446</tbody> 2447</table></div></td> 2448</tr> 2449<tr> 2450<td><p><span class="term">Requires:</span></p></td> 2451<td><p><code class="computeroutput">pos</code> is a valid iterator pointing to the <code class="computeroutput"><a class="link" href="circular_idm46495624036048.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code> or its end.<br> 2452 Valid range <code class="computeroutput">[first, last)</code> where <code class="computeroutput">first</code> and <code class="computeroutput">last</code> meet the requirements of an <a href="https://www.boost.org/sgi/stl/InputIterator.html" target="_top">InputIterator</a>. </p></td> 2453</tr> 2454<tr> 2455<td><p><span class="term">Postconditions:</span></p></td> 2456<td><p>Elements from the range <code class="computeroutput">[first, last - max[0, distance(first, last) - (end() - pos) - reserve()])</code> will be inserted before the position <code class="computeroutput">pos</code>.<br> 2457The number of <code class="computeroutput">min[end() - pos, max[0, distance(first, last) - reserve()]]</code> elements will be overwritten at the end of the <code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code>.<br> 2458(See <span class="emphasis"><em>Example</em></span> for the explanation.)<br> 2459<br> 2460 The amount of allocated memory in the internal buffer may be predictively increased. </p></td> 2461</tr> 2462<tr> 2463<td><p><span class="term">Throws:</span></p></td> 2464<td>An allocation error if memory is exhausted (<code class="computeroutput">std::bad_alloc</code> if the standard allocator is used). Whatever <code class="computeroutput">T::T(const T&)</code> throws. Whatever <code class="computeroutput">T::operator = (const T&)</code> throws. </td> 2465</tr> 2466</tbody> 2467</table></div> 2468</li> 2469<li class="listitem"> 2470<pre class="literallayout"><span class="identifier">iterator</span> <a name="idm46495623359728-bb"></a><span class="identifier">erase</span><span class="special">(</span><span class="identifier">iterator</span> pos<span class="special">)</span><span class="special">;</span></pre>Remove an element at the specified position. <p> 2471 2472 2473 2474 2475</p> 2476<p><b>Exception Safety. </b>Basic. </p> 2477<p> 2478</p> 2479<p><b>Iterator Invalidation. </b>Invalidates all iterators pointing to the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_idm46495624036048.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code> (except iterators equal to <code class="computeroutput">end()</code>). </p> 2480<p> 2481</p> 2482<p><b>Complexity. </b>Linear (in the size of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_idm46495624036048.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code>). </p> 2483<p> 2484</p> 2485<p><span class="bold"><strong>See Also:</strong></span></p> 2486<p><code class="computeroutput">erase(iterator, iterator)</code>, <code class="computeroutput">rerase(iterator)</code>, <code class="computeroutput">rerase(iterator, iterator)</code>, <code class="computeroutput">clear()</code> </p> 2487<p> 2488</p> 2489<p> 2490</p> 2491<div class="variablelist"><table border="0" class="variablelist compact"> 2492<colgroup> 2493<col align="left" valign="top"> 2494<col> 2495</colgroup> 2496<tbody> 2497<tr> 2498<td><p><span class="term">Parameters:</span></p></td> 2499<td><div class="variablelist"><table border="0" class="variablelist compact"> 2500<colgroup> 2501<col align="left" valign="top"> 2502<col> 2503</colgroup> 2504<tbody><tr> 2505<td><p><span class="term"><code class="computeroutput">pos</code></span></p></td> 2506<td><p>An iterator pointing at the element to be removed. </p></td> 2507</tr></tbody> 2508</table></div></td> 2509</tr> 2510<tr> 2511<td><p><span class="term">Requires:</span></p></td> 2512<td><p><code class="computeroutput">pos</code> is a valid iterator pointing to the <code class="computeroutput"><a class="link" href="circular_idm46495624036048.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code> (but not an <code class="computeroutput">end()</code>). </p></td> 2513</tr> 2514<tr> 2515<td><p><span class="term">Postconditions:</span></p></td> 2516<td><p>The element at the position <code class="computeroutput">pos</code> is removed.<br> 2517<br> 2518 The amount of allocated memory in the internal buffer may be predictively decreased. </p></td> 2519</tr> 2520<tr> 2521<td><p><span class="term">Returns:</span></p></td> 2522<td><p>Iterator to the first element remaining beyond the removed element or <code class="computeroutput">end()</code> if no such element exists. </p></td> 2523</tr> 2524<tr> 2525<td><p><span class="term">Throws:</span></p></td> 2526<td>An allocation error if memory is exhausted (<code class="computeroutput">std::bad_alloc</code> if the standard allocator is used). Whatever <code class="computeroutput">T::operator = (const T&)</code> throws or nothing if <code class="computeroutput">T::operator = (T&&)</code> is noexcept. </td> 2527</tr> 2528</tbody> 2529</table></div> 2530</li> 2531<li class="listitem"> 2532<pre class="literallayout"><span class="identifier">iterator</span> <a name="idm46495623341616-bb"></a><span class="identifier">erase</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>Erase the range <code class="computeroutput">[first, last)</code>. <p> 2533 2534 2535 2536 2537</p> 2538<p><b>Exception Safety. </b>Basic. </p> 2539<p> 2540</p> 2541<p><b>Iterator Invalidation. </b>Invalidates all iterators pointing to the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_idm46495624036048.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code> (except iterators equal to <code class="computeroutput">end()</code>). </p> 2542<p> 2543</p> 2544<p><b>Complexity. </b>Linear (in the size of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_idm46495624036048.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code>). </p> 2545<p> 2546</p> 2547<p><span class="bold"><strong>See Also:</strong></span></p> 2548<p><code class="computeroutput">erase(iterator)</code>, <code class="computeroutput">rerase(iterator)</code>, <code class="computeroutput">rerase(iterator, iterator)</code>, <code class="computeroutput">clear()</code> </p> 2549<p> 2550</p> 2551<p> 2552</p> 2553<div class="variablelist"><table border="0" class="variablelist compact"> 2554<colgroup> 2555<col align="left" valign="top"> 2556<col> 2557</colgroup> 2558<tbody> 2559<tr> 2560<td><p><span class="term">Parameters:</span></p></td> 2561<td><div class="variablelist"><table border="0" class="variablelist compact"> 2562<colgroup> 2563<col align="left" valign="top"> 2564<col> 2565</colgroup> 2566<tbody> 2567<tr> 2568<td><p><span class="term"><code class="computeroutput">first</code></span></p></td> 2569<td><p>The beginning of the range to be removed. </p></td> 2570</tr> 2571<tr> 2572<td><p><span class="term"><code class="computeroutput">last</code></span></p></td> 2573<td><p>The end of the range to be removed. </p></td> 2574</tr> 2575</tbody> 2576</table></div></td> 2577</tr> 2578<tr> 2579<td><p><span class="term">Requires:</span></p></td> 2580<td><p>Valid range <code class="computeroutput">[first, last)</code>. </p></td> 2581</tr> 2582<tr> 2583<td><p><span class="term">Postconditions:</span></p></td> 2584<td><p>The elements from the range <code class="computeroutput">[first, last)</code> are removed. (If <code class="computeroutput">first == last</code> nothing is removed.)<br> 2585<br> 2586 The amount of allocated memory in the internal buffer may be predictively decreased. </p></td> 2587</tr> 2588<tr> 2589<td><p><span class="term">Returns:</span></p></td> 2590<td><p>Iterator to the first element remaining beyond the removed elements or <code class="computeroutput">end()</code> if no such element exists. </p></td> 2591</tr> 2592<tr> 2593<td><p><span class="term">Throws:</span></p></td> 2594<td>An allocation error if memory is exhausted (<code class="computeroutput">std::bad_alloc</code> if the standard allocator is used). Whatever <code class="computeroutput">T::operator = (const T&)</code> throws or nothing if <code class="computeroutput">T::operator = (T&&)</code> is noexcept. </td> 2595</tr> 2596</tbody> 2597</table></div> 2598</li> 2599<li class="listitem"> 2600<pre class="literallayout"><span class="identifier">iterator</span> <a name="idm46495623322720-bb"></a><span class="identifier">rerase</span><span class="special">(</span><span class="identifier">iterator</span> pos<span class="special">)</span><span class="special">;</span></pre>Remove an element at the specified position. <p> 2601 2602 2603 2604 2605</p> 2606<p><b>Exception Safety. </b>Basic. </p> 2607<p> 2608</p> 2609<p><b>Iterator Invalidation. </b>Invalidates all iterators pointing to the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_idm46495624036048.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code> (except iterators equal to <code class="computeroutput">end()</code>). </p> 2610<p> 2611</p> 2612<p><b>Complexity. </b>Linear (in the size of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_idm46495624036048.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code>). </p> 2613<p> 2614</p> 2615<div class="note"><table border="0" summary="Note"> 2616<tr> 2617<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../doc/src/images/note.png"></td> 2618<th align="left">Note</th> 2619</tr> 2620<tr><td align="left" valign="top"><p>Basically there is no difference between <code class="computeroutput">erase(iterator)</code> and this method. It is implemented only for consistency with the base <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code>. </p></td></tr> 2621</table></div> 2622<p> 2623</p> 2624<p><span class="bold"><strong>See Also:</strong></span></p> 2625<p><code class="computeroutput">erase(iterator)</code>, <code class="computeroutput">erase(iterator, iterator)</code>, <code class="computeroutput">rerase(iterator, iterator)</code>, <code class="computeroutput">clear()</code> </p> 2626<p> 2627</p> 2628<p> 2629</p> 2630<div class="variablelist"><table border="0" class="variablelist compact"> 2631<colgroup> 2632<col align="left" valign="top"> 2633<col> 2634</colgroup> 2635<tbody> 2636<tr> 2637<td><p><span class="term">Parameters:</span></p></td> 2638<td><div class="variablelist"><table border="0" class="variablelist compact"> 2639<colgroup> 2640<col align="left" valign="top"> 2641<col> 2642</colgroup> 2643<tbody><tr> 2644<td><p><span class="term"><code class="computeroutput">pos</code></span></p></td> 2645<td><p>An iterator pointing at the element to be removed. </p></td> 2646</tr></tbody> 2647</table></div></td> 2648</tr> 2649<tr> 2650<td><p><span class="term">Requires:</span></p></td> 2651<td><p><code class="computeroutput">pos</code> is a valid iterator pointing to the <code class="computeroutput"><a class="link" href="circular_idm46495624036048.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code> (but not an <code class="computeroutput">end()</code>).<br> 2652<br> 2653 The amount of allocated memory in the internal buffer may be predictively decreased. </p></td> 2654</tr> 2655<tr> 2656<td><p><span class="term">Postconditions:</span></p></td> 2657<td><p>The element at the position <code class="computeroutput">pos</code> is removed. </p></td> 2658</tr> 2659<tr> 2660<td><p><span class="term">Returns:</span></p></td> 2661<td><p>Iterator to the first element remaining in front of the removed element or <code class="computeroutput">begin()</code> if no such element exists. </p></td> 2662</tr> 2663<tr> 2664<td><p><span class="term">Throws:</span></p></td> 2665<td>An allocation error if memory is exhausted (<code class="computeroutput">std::bad_alloc</code> if the standard allocator is used). Whatever <code class="computeroutput">T::operator = (const T&)</code> throws or nothing if <code class="computeroutput">T::operator = (T&&)</code> is noexcept. </td> 2666</tr> 2667</tbody> 2668</table></div> 2669</li> 2670<li class="listitem"> 2671<pre class="literallayout"><span class="identifier">iterator</span> <a name="idm46495623302480-bb"></a><span class="identifier">rerase</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>Erase the range <code class="computeroutput">[first, last)</code>. <p> 2672 2673 2674 2675 2676</p> 2677<p><b>Exception Safety. </b>Basic. </p> 2678<p> 2679</p> 2680<p><b>Iterator Invalidation. </b>Invalidates all iterators pointing to the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_idm46495624036048.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code> (except iterators equal to <code class="computeroutput">end()</code>). </p> 2681<p> 2682</p> 2683<p><b>Complexity. </b>Linear (in the size of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_idm46495624036048.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code>). </p> 2684<p> 2685</p> 2686<div class="note"><table border="0" summary="Note"> 2687<tr> 2688<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../doc/src/images/note.png"></td> 2689<th align="left">Note</th> 2690</tr> 2691<tr><td align="left" valign="top"><p>Basically there is no difference between <code class="computeroutput">erase(iterator, iterator)</code> and this method. It is implemented only for consistency with the base <code class="computeroutput"><<code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code>. </p></td></tr> 2692</table></div> 2693<p> 2694</p> 2695<p><span class="bold"><strong>See Also:</strong></span></p> 2696<p><code class="computeroutput">erase(iterator)</code>, <code class="computeroutput">erase(iterator, iterator)</code>, <code class="computeroutput">rerase(iterator)</code>, <code class="computeroutput">clear()</code> </p> 2697<p> 2698</p> 2699<p> 2700</p> 2701<div class="variablelist"><table border="0" class="variablelist compact"> 2702<colgroup> 2703<col align="left" valign="top"> 2704<col> 2705</colgroup> 2706<tbody> 2707<tr> 2708<td><p><span class="term">Parameters:</span></p></td> 2709<td><div class="variablelist"><table border="0" class="variablelist compact"> 2710<colgroup> 2711<col align="left" valign="top"> 2712<col> 2713</colgroup> 2714<tbody> 2715<tr> 2716<td><p><span class="term"><code class="computeroutput">first</code></span></p></td> 2717<td><p>The beginning of the range to be removed. </p></td> 2718</tr> 2719<tr> 2720<td><p><span class="term"><code class="computeroutput">last</code></span></p></td> 2721<td><p>The end of the range to be removed. </p></td> 2722</tr> 2723</tbody> 2724</table></div></td> 2725</tr> 2726<tr> 2727<td><p><span class="term">Requires:</span></p></td> 2728<td><p>Valid range <code class="computeroutput">[first, last)</code>. </p></td> 2729</tr> 2730<tr> 2731<td><p><span class="term">Postconditions:</span></p></td> 2732<td><p>The elements from the range <code class="computeroutput">[first, last)</code> are removed. (If <code class="computeroutput">first == last</code> nothing is removed.)<br> 2733<br> 2734 The amount of allocated memory in the internal buffer may be predictively decreased. </p></td> 2735</tr> 2736<tr> 2737<td><p><span class="term">Returns:</span></p></td> 2738<td><p>Iterator to the first element remaining in front of the removed elements or <code class="computeroutput">begin()</code> if no such element exists. </p></td> 2739</tr> 2740<tr> 2741<td><p><span class="term">Throws:</span></p></td> 2742<td>An allocation error if memory is exhausted (<code class="computeroutput">std::bad_alloc</code> if the standard allocator is used). Whatever <code class="computeroutput">T::operator = (const T&)</code> throws or nothing if <code class="computeroutput">T::operator = (T&&)</code> is noexcept. </td> 2743</tr> 2744</tbody> 2745</table></div> 2746</li> 2747<li class="listitem"> 2748<pre class="literallayout"><span class="keyword">void</span> <a name="idm46495623281280-bb"></a><span class="identifier">clear</span><span class="special">(</span><span class="special">)</span><span class="special">;</span></pre>Remove all stored elements from the space optimized circular buffer. <p> 2749 2750</p> 2751<p><b>Exception Safety. </b>Basic. </p> 2752<p> 2753</p> 2754<p><b>Iterator Invalidation. </b>Invalidates all iterators pointing to the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_idm46495624036048.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code> (except iterators equal to <code class="computeroutput">end()</code>). </p> 2755<p> 2756</p> 2757<p><b>Complexity. </b>Linear (in the size of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_idm46495624036048.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code>). </p> 2758<p> 2759</p> 2760<p><span class="bold"><strong>See Also:</strong></span></p> 2761<p><code class="computeroutput">~circular_buffer_space_optimized()</code>, <code class="computeroutput">erase(iterator)</code>, <code class="computeroutput">erase(iterator, iterator)</code>, <code class="computeroutput">rerase(iterator)</code>, <code class="computeroutput">rerase(iterator, iterator)</code> </p> 2762<p> 2763</p> 2764<p> 2765</p> 2766<div class="variablelist"><table border="0" class="variablelist compact"> 2767<colgroup> 2768<col align="left" valign="top"> 2769<col> 2770</colgroup> 2771<tbody> 2772<tr> 2773<td><p><span class="term">Postconditions:</span></p></td> 2774<td><p><code class="computeroutput">size() == 0</code><br> 2775<br> 2776 The amount of allocated memory in the internal buffer may be predictively decreased. </p></td> 2777</tr> 2778<tr> 2779<td><p><span class="term">Throws:</span></p></td> 2780<td>An allocation error if memory is exhausted (<code class="computeroutput">std::bad_alloc</code> if the standard allocator is used). </td> 2781</tr> 2782</tbody> 2783</table></div> 2784</li> 2785</ol></div> 2786</div> 2787</div> 2788</div> 2789<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr> 2790<td align="left"></td> 2791<td align="right"><div class="copyright-footer">Copyright © 2003-2013 Jan Gaspar<p> 2792 Distributed under the Boost Software License, Version 1.0. (See accompanying 2793 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>) 2794 </p> 2795</div></td> 2796</tr></table> 2797<hr> 2798<div class="spirit-nav"> 2799<a accesskey="p" href="swap_idm46495624055088.html"><img src="../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../boost_circular_buffer_c___reference.html#header.boost.circular_buffer.space_optimized_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="../circular_buffer/s14.html"><img src="../../../doc/src/images/next.png" alt="Next"></a> 2800</div> 2801</body> 2802</html> 2803
