1<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd"> 2<html> 3<head> 4<meta http-equiv="Content-Type" content="text/html; charset=UTF-8"> 5<title>Class template circular_buffer</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.base_hpp" title="Header <boost/circular_buffer/base.hpp>"> 10<link rel="prev" href="../BOOST_CB_ENABLE_DEBUG.html" title="Macro BOOST_CB_ENABLE_DEBUG"> 11<link rel="next" href="operator_idm45227212472336.html" title="Function template operator=="> 12</head> 13<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"> 14<table cellpadding="2" width="100%"><tr> 15<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../boost.png"></td> 16<td align="center"><a href="../../../index.html">Home</a></td> 17<td align="center"><a href="../../../libs/libraries.htm">Libraries</a></td> 18<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td> 19<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td> 20<td align="center"><a href="../../../more/index.htm">More</a></td> 21</tr></table> 22<hr> 23<div class="spirit-nav"> 24<a accesskey="p" href="../BOOST_CB_ENABLE_DEBUG.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.base_hpp"><img src="../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="operator_idm45227212472336.html"><img src="../../../doc/src/images/next.png" alt="Next"></a> 25</div> 26<div class="refentry"> 27<a name="boost.circular_buffer"></a><div class="titlepage"></div> 28<div class="refnamediv"> 29<h2><span class="refentrytitle">Class template circular_buffer</span></h2> 30<p>boost::circular_buffer — Circular buffer - a STL compliant container. </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.base_hpp" title="Header <boost/circular_buffer/base.hpp>">boost/circular_buffer/base.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_buffer.html" title="Class template circular_buffer">circular_buffer</a> <span class="special">:</span> <span class="keyword">private</span> <span class="identifier">empty_value</span><span class="special"><</span> <span class="identifier">Alloc</span> <span class="special">></span> <span class="special">{</span> 37<span class="keyword">public</span><span class="special">:</span> 38 <span class="comment">// <a class="link" href="circular_buffer.html#boost.circular_buffertypes">types</a></span> 39 <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> <a name="boost.circular_buffer.this_type"></a><span class="identifier">this_type</span><span class="special">;</span> <span class="comment">// The type of this <code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code>. </span> 40 <span class="keyword">typedef</span> <span class="identifier">Alloc</span><span class="special">::</span><span class="identifier">value_type</span> <a name="boost.circular_buffer.value_type"></a><span class="identifier">value_type</span><span class="special">;</span> <span class="comment">// The type of elements stored in the <code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code>. </span> 41 <span class="keyword">typedef</span> <span class="identifier">allocator_pointer</span><span class="special"><</span> <span class="identifier">Alloc</span> <span class="special">></span><span class="special">::</span><span class="identifier">type</span> <a name="boost.circular_buffer.pointer"></a><span class="identifier">pointer</span><span class="special">;</span> <span class="comment">// A pointer to an element. </span> 42 <span class="keyword">typedef</span> <span class="identifier">allocator_const_pointer</span><span class="special"><</span> <span class="identifier">Alloc</span> <span class="special">></span><span class="special">::</span><span class="identifier">type</span> <a name="boost.circular_buffer.const_pointer"></a><span class="identifier">const_pointer</span><span class="special">;</span> <span class="comment">// A const pointer to the element. </span> 43 <span class="keyword">typedef</span> <span class="identifier">value_type</span> <span class="special">&</span> <a name="boost.circular_buffer.reference"></a><span class="identifier">reference</span><span class="special">;</span> <span class="comment">// A reference to an element. </span> 44 <span class="keyword">typedef</span> <span class="keyword">const</span> <span class="identifier">value_type</span> <span class="special">&</span> <a name="boost.circular_buffer.const_reference"></a><span class="identifier">const_reference</span><span class="special">;</span> <span class="comment">// A const reference to an element. </span> 45 <span class="keyword">typedef</span> <span class="identifier">allocator_difference_type</span><span class="special"><</span> <span class="identifier">Alloc</span> <span class="special">></span><span class="special">::</span><span class="identifier">type</span> <a class="link" href="circular_buffer.html#boost.circular_buffer.difference_type"><span class="identifier">difference_type</span></a><span class="special">;</span> 46 <span class="keyword">typedef</span> <span class="identifier">allocator_size_type</span><span class="special"><</span> <span class="identifier">Alloc</span> <span class="special">></span><span class="special">::</span><span class="identifier">type</span> <a class="link" href="circular_buffer.html#boost.circular_buffer.size_type"><span class="identifier">size_type</span></a><span class="special">;</span> 47 <span class="keyword">typedef</span> <span class="identifier">Alloc</span> <a name="boost.circular_buffer.allocator_type"></a><span class="identifier">allocator_type</span><span class="special">;</span> <span class="comment">// The type of an allocator used in the <code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code>. </span> 48 <span class="keyword">typedef</span> <span class="identifier">cb_details</span><span class="special">::</span><span class="identifier">iterator</span><span class="special"><</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">cb_details</span><span class="special">::</span><span class="identifier">const_traits</span><span class="special"><</span> <span class="identifier">Alloc</span> <span class="special">></span> <span class="special">></span> <a name="boost.circular_buffer.const_iterator"></a><span class="identifier">const_iterator</span><span class="special">;</span> <span class="comment">// A const (random access) iterator used to iterate through the <code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code>. </span> 49 <span class="keyword">typedef</span> <span class="identifier">cb_details</span><span class="special">::</span><span class="identifier">iterator</span><span class="special"><</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">cb_details</span><span class="special">::</span><span class="identifier">nonconst_traits</span><span class="special"><</span> <span class="identifier">Alloc</span> <span class="special">></span> <span class="special">></span> <a name="boost.circular_buffer.iterator"></a><span class="identifier">iterator</span><span class="special">;</span> <span class="comment">// A (random access) iterator used to iterate through the <code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code>. </span> 50 <span class="keyword">typedef</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">reverse_iterator</span><span class="special"><</span> <span class="identifier">const_iterator</span> <span class="special">></span> <a name="boost.circular_buffer.const_reverse_iterator"></a><span class="identifier">const_reverse_iterator</span><span class="special">;</span> <span class="comment">// A const iterator used to iterate backwards through a <code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code>. </span> 51 <span class="keyword">typedef</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">reverse_iterator</span><span class="special"><</span> <span class="identifier">iterator</span> <span class="special">></span> <a name="boost.circular_buffer.reverse_iterator"></a><span class="identifier">reverse_iterator</span><span class="special">;</span> <span class="comment">// An iterator used to iterate backwards through a <code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code>. </span> 52 <span class="keyword">typedef</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special"><</span> <span class="identifier">pointer</span><span class="special">,</span> <span class="identifier">size_type</span> <span class="special">></span> <a class="link" href="circular_buffer.html#boost.circular_buffer.array_range"><span class="identifier">array_range</span></a><span class="special">;</span> 53 <span class="keyword">typedef</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special"><</span> <span class="identifier">const_pointer</span><span class="special">,</span> <span class="identifier">size_type</span> <span class="special">></span> <a class="link" href="circular_buffer.html#boost.circular_buffer.const_array_range"><span class="identifier">const_array_range</span></a><span class="special">;</span> 54 <span class="keyword">typedef</span> <span class="identifier">size_type</span> <a class="link" href="circular_buffer.html#boost.circular_buffer.capacity_type"><span class="identifier">capacity_type</span></a><span class="special">;</span> 55 <span class="keyword">typedef</span> <span class="keyword">const</span> <span class="identifier">value_type</span> <span class="special">&</span> <a name="boost.circular_buffer.param_value_type"></a><span class="identifier">param_value_type</span><span class="special">;</span> <span class="comment">// A type representing the "best" way to pass the value_type to a method. </span> 56 <span class="keyword">typedef</span> <span class="identifier">value_type</span> <span class="special">&&</span> <a class="link" href="circular_buffer.html#boost.circular_buffer.rvalue_type"><span class="identifier">rvalue_type</span></a><span class="special">;</span> 57 58 <span class="comment">// <a class="link" href="circular_buffer.html#boost.circular_bufferconstruct-copy-destruct">construct/copy/destruct</a></span> 59 <span class="keyword">explicit</span> <a class="link" href="circular_buffer.html#idm45227212602608-bb"><span class="identifier">circular_buffer</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> 60 <span class="keyword">explicit</span> <a class="link" href="circular_buffer.html#idm45227212590048-bb"><span class="identifier">circular_buffer</span></a><span class="special">(</span><span class="identifier">capacity_type</span><span class="special">,</span> 61 <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> 62 <a class="link" href="circular_buffer.html#idm45227212581424-bb"><span class="identifier">circular_buffer</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> 63 <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> 64 <a class="link" href="circular_buffer.html#idm45227212569264-bb"><span class="identifier">circular_buffer</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> 65 <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> 66 <a class="link" href="circular_buffer.html#idm45227212554240-bb"><span class="identifier">circular_buffer</span></a><span class="special">(</span><span class="keyword">const</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="special">)</span><span class="special">;</span> 67 <a class="link" href="circular_buffer.html#idm45227212546000-bb"><span class="identifier">circular_buffer</span></a><span class="special">(</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="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span> 68 <span class="keyword">template</span><span class="special"><</span><span class="keyword">typename</span> InputIterator<span class="special">></span> 69 <a class="link" href="circular_buffer.html#idm45227212537856-bb"><span class="identifier">circular_buffer</span></a><span class="special">(</span><span class="identifier">InputIterator</span><span class="special">,</span> <span class="identifier">InputIterator</span><span class="special">,</span> 70 <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> 71 <span class="keyword">template</span><span class="special"><</span><span class="keyword">typename</span> InputIterator<span class="special">></span> 72 <a class="link" href="circular_buffer.html#idm45227212524368-bb"><span class="identifier">circular_buffer</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> 73 <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> 74 <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> <a class="link" href="circular_buffer.html#idm45227212496912-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_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="special">)</span><span class="special">;</span> 75 <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> 76 <a class="link" href="circular_buffer.html#idm45227212480832-bb"><span class="keyword">operator</span><span class="special">=</span></a><span class="special">(</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="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span> 77 <a class="link" href="circular_buffer.html#idm45227212505328-bb"><span class="special">~</span><span class="identifier">circular_buffer</span></a><span class="special">(</span><span class="special">)</span><span class="special">;</span> 78 79 <span class="comment">// <a class="link" href="circular_buffer.html#idm45227213704720-bb">public member functions</a></span> 80 <span class="identifier">allocator_type</span> <a class="link" href="circular_buffer.html#idm45227213704160-bb"><span class="identifier">get_allocator</span></a><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span> 81 <span class="identifier">allocator_type</span> <span class="special">&</span> <a class="link" href="circular_buffer.html#idm45227213695504-bb"><span class="identifier">get_allocator</span></a><span class="special">(</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span> 82 <span class="identifier">iterator</span> <a class="link" href="circular_buffer.html#idm45227213686000-bb"><span class="identifier">begin</span></a><span class="special">(</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span> 83 <span class="identifier">iterator</span> <a class="link" href="circular_buffer.html#idm45227213673504-bb"><span class="identifier">end</span></a><span class="special">(</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span> 84 <span class="identifier">const_iterator</span> <a class="link" href="circular_buffer.html#idm45227213660672-bb"><span class="identifier">begin</span></a><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span> 85 <span class="identifier">const_iterator</span> <a class="link" href="circular_buffer.html#idm45227213648000-bb"><span class="identifier">cbegin</span></a><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span> 86 <span class="identifier">const_iterator</span> <a class="link" href="circular_buffer.html#idm45227213646880-bb"><span class="identifier">end</span></a><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span> 87 <span class="identifier">const_iterator</span> <a class="link" href="circular_buffer.html#idm45227213634032-bb"><span class="identifier">cend</span></a><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span> 88 <span class="identifier">reverse_iterator</span> <a class="link" href="circular_buffer.html#idm45227213632912-bb"><span class="identifier">rbegin</span></a><span class="special">(</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span> 89 <span class="identifier">reverse_iterator</span> <a class="link" href="circular_buffer.html#idm45227213620240-bb"><span class="identifier">rend</span></a><span class="special">(</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span> 90 <span class="identifier">const_reverse_iterator</span> <a class="link" href="circular_buffer.html#idm45227213607392-bb"><span class="identifier">rbegin</span></a><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span> 91 <span class="identifier">const_reverse_iterator</span> <a class="link" href="circular_buffer.html#idm45227213594704-bb"><span class="identifier">rend</span></a><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span> 92 <span class="identifier">reference</span> <a class="link" href="circular_buffer.html#idm45227213582000-bb"><span class="keyword">operator</span> <span class="special">[</span><span class="special">]</span></a><span class="special">(</span><span class="identifier">size_type</span><span class="special">)</span><span class="special">;</span> 93 <span class="identifier">const_reference</span> <a class="link" href="circular_buffer.html#idm45227213570720-bb"><span class="keyword">operator</span> <span class="special">[</span><span class="special">]</span></a><span class="special">(</span><span class="identifier">size_type</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span> 94 <span class="identifier">reference</span> <a class="link" href="circular_buffer.html#idm45227213559152-bb"><span class="identifier">at</span></a><span class="special">(</span><span class="identifier">size_type</span><span class="special">)</span><span class="special">;</span> 95 <span class="identifier">const_reference</span> <a class="link" href="circular_buffer.html#idm45227213547840-bb"><span class="identifier">at</span></a><span class="special">(</span><span class="identifier">size_type</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span> 96 <span class="identifier">reference</span> <a class="link" href="circular_buffer.html#idm45227213536240-bb"><span class="identifier">front</span></a><span class="special">(</span><span class="special">)</span><span class="special">;</span> 97 <span class="identifier">reference</span> <a class="link" href="circular_buffer.html#idm45227213526128-bb"><span class="identifier">back</span></a><span class="special">(</span><span class="special">)</span><span class="special">;</span> 98 <span class="identifier">const_reference</span> <a class="link" href="circular_buffer.html#idm45227213516032-bb"><span class="identifier">front</span></a><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span> 99 <span class="identifier">const_reference</span> <a class="link" href="circular_buffer.html#idm45227213505648-bb"><span class="identifier">back</span></a><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span> 100 <span class="identifier">array_range</span> <a class="link" href="circular_buffer.html#idm45227213495264-bb"><span class="identifier">array_one</span></a><span class="special">(</span><span class="special">)</span><span class="special">;</span> 101 <span class="identifier">array_range</span> <a class="link" href="circular_buffer.html#idm45227213461936-bb"><span class="identifier">array_two</span></a><span class="special">(</span><span class="special">)</span><span class="special">;</span> 102 <span class="identifier">const_array_range</span> <a class="link" href="circular_buffer.html#idm45227213451552-bb"><span class="identifier">array_one</span></a><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span> 103 <span class="identifier">const_array_range</span> <a class="link" href="circular_buffer.html#idm45227213440464-bb"><span class="identifier">array_two</span></a><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span> 104 <span class="identifier">pointer</span> <a class="link" href="circular_buffer.html#idm45227213429808-bb"><span class="identifier">linearize</span></a><span class="special">(</span><span class="special">)</span><span class="special">;</span> 105 <span class="keyword">bool</span> <a class="link" href="circular_buffer.html#idm45227213413904-bb"><span class="identifier">is_linearized</span></a><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span> 106 <span class="keyword">void</span> <a class="link" href="circular_buffer.html#idm45227213401392-bb"><span class="identifier">rotate</span></a><span class="special">(</span><span class="identifier">const_iterator</span><span class="special">)</span><span class="special">;</span> 107 <span class="identifier">size_type</span> <a class="link" href="circular_buffer.html#idm45227213375216-bb"><span class="identifier">size</span></a><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span> 108 <span class="identifier">size_type</span> <a class="link" href="circular_buffer.html#idm45227213363472-bb"><span class="identifier">max_size</span></a><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span> 109 <span class="keyword">bool</span> <a class="link" href="circular_buffer.html#idm45227213352160-bb"><span class="identifier">empty</span></a><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span> 110 <span class="keyword">bool</span> <a class="link" href="circular_buffer.html#idm45227213341056-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> 111 <span class="identifier">size_type</span> <a class="link" href="circular_buffer.html#idm45227213329088-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> 112 <span class="identifier">capacity_type</span> <a class="link" href="circular_buffer.html#idm45227213318336-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> 113 <span class="keyword">void</span> <a class="link" href="circular_buffer.html#idm45227213306576-bb"><span class="identifier">set_capacity</span></a><span class="special">(</span><span class="identifier">capacity_type</span><span class="special">)</span><span class="special">;</span> 114 <span class="keyword">void</span> <a class="link" href="circular_buffer.html#idm45227213288080-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> 115 <span class="keyword">void</span> <a class="link" href="circular_buffer.html#idm45227213265840-bb"><span class="identifier">rset_capacity</span></a><span class="special">(</span><span class="identifier">capacity_type</span><span class="special">)</span><span class="special">;</span> 116 <span class="keyword">void</span> <a class="link" href="circular_buffer.html#idm45227213247344-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> 117 <span class="keyword">void</span> <a class="link" href="circular_buffer.html#idm45227213225104-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> 118 <span class="keyword">void</span> <a class="link" href="circular_buffer.html#idm45227213206096-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> 119 <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_buffer.html#idm45227213184208-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> 120 <span class="keyword">template</span><span class="special"><</span><span class="keyword">typename</span> InputIterator<span class="special">></span> 121 <span class="keyword">void</span> <a class="link" href="circular_buffer.html#idm45227213164224-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> 122 <span class="keyword">void</span> <a class="link" href="circular_buffer.html#idm45227213138704-bb"><span class="identifier">swap</span></a><span class="special">(</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="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span> 123 <span class="keyword">void</span> <a class="link" href="circular_buffer.html#idm45227213123440-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> 124 <span class="keyword">void</span> <a class="link" href="circular_buffer.html#idm45227213108320-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> 125 <span class="keyword">void</span> <a class="link" href="circular_buffer.html#idm45227213093168-bb"><span class="identifier">push_back</span></a><span class="special">(</span><span class="special">)</span><span class="special">;</span> 126 <span class="keyword">void</span> <a class="link" href="circular_buffer.html#idm45227213078704-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> 127 <span class="keyword">void</span> <a class="link" href="circular_buffer.html#idm45227213063568-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> 128 <span class="keyword">void</span> <a class="link" href="circular_buffer.html#idm45227213048400-bb"><span class="identifier">push_front</span></a><span class="special">(</span><span class="special">)</span><span class="special">;</span> 129 <span class="keyword">void</span> <a class="link" href="circular_buffer.html#idm45227213033936-bb"><span class="identifier">pop_back</span></a><span class="special">(</span><span class="special">)</span><span class="special">;</span> 130 <span class="keyword">void</span> <a class="link" href="circular_buffer.html#idm45227213022016-bb"><span class="identifier">pop_front</span></a><span class="special">(</span><span class="special">)</span><span class="special">;</span> 131 <span class="identifier">iterator</span> <a class="link" href="circular_buffer.html#idm45227213010096-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> 132 <span class="identifier">iterator</span> <a class="link" href="circular_buffer.html#idm45227212985728-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> 133 <span class="identifier">iterator</span> <a class="link" href="circular_buffer.html#idm45227212961376-bb"><span class="identifier">insert</span></a><span class="special">(</span><span class="identifier">iterator</span><span class="special">)</span><span class="special">;</span> 134 <span class="keyword">void</span> <a class="link" href="circular_buffer.html#idm45227212937680-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> 135 <span class="keyword">template</span><span class="special"><</span><span class="keyword">typename</span> InputIterator<span class="special">></span> 136 <span class="keyword">void</span> <a class="link" href="circular_buffer.html#idm45227212905328-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> 137 <span class="identifier">iterator</span> <a class="link" href="circular_buffer.html#idm45227212864960-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> 138 <span class="identifier">iterator</span> <a class="link" href="circular_buffer.html#idm45227212841088-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> 139 <span class="identifier">iterator</span> <a class="link" href="circular_buffer.html#idm45227212817232-bb"><span class="identifier">rinsert</span></a><span class="special">(</span><span class="identifier">iterator</span><span class="special">)</span><span class="special">;</span> 140 <span class="keyword">void</span> <a class="link" href="circular_buffer.html#idm45227212794048-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> 141 <span class="keyword">template</span><span class="special"><</span><span class="keyword">typename</span> InputIterator<span class="special">></span> 142 <span class="keyword">void</span> <a class="link" href="circular_buffer.html#idm45227212762208-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> 143 <span class="identifier">iterator</span> <a class="link" href="circular_buffer.html#idm45227212722288-bb"><span class="identifier">erase</span></a><span class="special">(</span><span class="identifier">iterator</span><span class="special">)</span><span class="special">;</span> 144 <span class="identifier">iterator</span> <a class="link" href="circular_buffer.html#idm45227212705952-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> 145 <span class="identifier">iterator</span> <a class="link" href="circular_buffer.html#idm45227212688800-bb"><span class="identifier">rerase</span></a><span class="special">(</span><span class="identifier">iterator</span><span class="special">)</span><span class="special">;</span> 146 <span class="identifier">iterator</span> <a class="link" href="circular_buffer.html#idm45227212669488-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> 147 <span class="keyword">void</span> <a class="link" href="circular_buffer.html#idm45227212650160-bb"><span class="identifier">erase_begin</span></a><span class="special">(</span><span class="identifier">size_type</span><span class="special">)</span><span class="special">;</span> 148 <span class="keyword">void</span> <a class="link" href="circular_buffer.html#idm45227212633392-bb"><span class="identifier">erase_end</span></a><span class="special">(</span><span class="identifier">size_type</span><span class="special">)</span><span class="special">;</span> 149 <span class="keyword">void</span> <a class="link" href="circular_buffer.html#idm45227212616640-bb"><span class="identifier">clear</span></a><span class="special">(</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span> 150<span class="special">}</span><span class="special">;</span></pre></div> 151<div class="refsect1"> 152<a name="id-1.3.9.16.3.3.4"></a><h2>Description</h2> 153<p> 154</p> 155<p><b>Type Requirements T. </b>The <code class="computeroutput">T</code> has to be <a href="https://www.boost.org/sgi/stl/Assignable.html" target="_top">SGIAssignable</a> (SGI STL defined combination of <a href="../../../../utility/Assignable.html" target="_top">Assignable</a> and <a href="../../../../utility/CopyConstructible.html" target="_top">CopyConstructible</a>). Moreover <code class="computeroutput">T</code> has to be <a href="https://www.boost.org/sgi/stl/DefaultConstructible.html" target="_top">DefaultConstructible</a> if supplied as a default parameter when invoking some of the <code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code>'s methods e.g. <code class="computeroutput">insert(iterator pos, const value_type& item = value_type())</code>. And <a href="https://www.boost.org/sgi/stl/EqualityComparable.html" target="_top">EqualityComparable</a> and/or <a href="../../../../utility/LessThanComparable.html" target="_top">LessThanComparable</a> if the <code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code> will be compared with another container. </p> 156<p> 157 158</p> 159<p><b>Type Requirements Alloc. </b>The <code class="computeroutput">Alloc</code> has to meet the allocator requirements imposed by STL. </p> 160<p> 161</p> 162<p><b>Default Alloc. </b>std::allocator<T></p> 163<p> 164For detailed documentation of the <a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a> visit: <a href="http://www.boost.org/libs/circular_buffer/doc/circular_buffer.html" target="_top">http://www.boost.org/libs/circular_buffer/doc/circular_buffer.html</a> </p> 165<div class="refsect2"> 166<a name="id-1.3.9.16.3.3.4.3"></a><h3>Template Parameters</h3> 167<div class="orderedlist"><ol class="orderedlist" type="1"> 168<li class="listitem"> 169<pre class="literallayout"><span class="keyword">typename</span> T</pre> 170<p>The type of the elements stored in the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code>. </p> 171</li> 172<li class="listitem"> 173<pre class="literallayout"><span class="keyword">typename</span> Alloc</pre> 174<p>The allocator type used for all internal memory management. </p> 175</li> 176</ol></div> 177</div> 178<div class="refsect2"> 179<a name="id-1.3.9.16.3.3.4.4"></a><h3> 180<a name="boost.circular_buffertypes"></a><code class="computeroutput">circular_buffer</code> 181 public 182 types</h3> 183<div class="orderedlist"><ol class="orderedlist" type="1"> 184<li class="listitem"> 185<p> 186<span class="keyword">typedef</span> <span class="identifier">allocator_difference_type</span><span class="special"><</span> <span class="identifier">Alloc</span> <span class="special">></span><span class="special">::</span><span class="identifier">type</span> <a name="boost.circular_buffer.difference_type"></a><span class="identifier">difference_type</span><span class="special">;</span></p> 187<p>(A signed integral type used to represent the distance between two iterators.) </p> 188</li> 189<li class="listitem"> 190<p> 191<span class="keyword">typedef</span> <span class="identifier">allocator_size_type</span><span class="special"><</span> <span class="identifier">Alloc</span> <span class="special">></span><span class="special">::</span><span class="identifier">type</span> <a name="boost.circular_buffer.size_type"></a><span class="identifier">size_type</span><span class="special">;</span></p> 192<p>(An unsigned integral type that can represent any non-negative value of the container's distance type.) </p> 193</li> 194<li class="listitem"> 195<p> 196<span class="keyword">typedef</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special"><</span> <span class="identifier">pointer</span><span class="special">,</span> <span class="identifier">size_type</span> <span class="special">></span> <a name="boost.circular_buffer.array_range"></a><span class="identifier">array_range</span><span class="special">;</span></p> 197<p>(A typedef for the <a href="https://www.boost.org/sgi/stl/pair.html" target="_top"><code class="computeroutput">std::pair</code></a> where its first element is a pointer to a beginning of an array and its second element represents a size of the array.) </p> 198</li> 199<li class="listitem"> 200<p> 201<span class="keyword">typedef</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special"><</span> <span class="identifier">const_pointer</span><span class="special">,</span> <span class="identifier">size_type</span> <span class="special">></span> <a name="boost.circular_buffer.const_array_range"></a><span class="identifier">const_array_range</span><span class="special">;</span></p> 202<p>(A typedef for the <a href="https://www.boost.org/sgi/stl/pair.html" target="_top"><code class="computeroutput">std::pair</code></a> where its first element is a pointer to a beginning of a const array and its second element represents a size of the const array.) </p> 203</li> 204<li class="listitem"> 205<p> 206<span class="keyword">typedef</span> <span class="identifier">size_type</span> <a name="boost.circular_buffer.capacity_type"></a><span class="identifier">capacity_type</span><span class="special">;</span></p> 207<p>(Same as <code class="computeroutput">size_type</code> - defined for consistency with the __cbso class. </p> 208</li> 209<li class="listitem"> 210<p> 211<span class="keyword">typedef</span> <span class="identifier">value_type</span> <span class="special">&&</span> <a name="boost.circular_buffer.rvalue_type"></a><span class="identifier">rvalue_type</span><span class="special">;</span></p> 212<p>A type representing rvalue from param type. On compilers without rvalue references support this type is the Boost.Moves type used for emulation. </p> 213</li> 214</ol></div> 215</div> 216<div class="refsect2"> 217<a name="id-1.3.9.16.3.3.4.5"></a><h3> 218<a name="boost.circular_bufferconstruct-copy-destruct"></a><code class="computeroutput">circular_buffer</code> 219 public 220 construct/copy/destruct</h3> 221<div class="orderedlist"><ol class="orderedlist" type="1"> 222<li class="listitem"> 223<pre class="literallayout"><span class="keyword">explicit</span> <a name="idm45227212602608-bb"></a><span class="identifier">circular_buffer</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 <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code> with zero capacity. <p> 224 225 226</p> 227<p><b>Complexity. </b>Constant. </p> 228<p> 229</p> 230<div class="warning"><table border="0" summary="Warning"> 231<tr> 232<td rowspan="2" align="center" valign="top" width="25"><img alt="[Warning]" src="../../../doc/src/images/warning.png"></td> 233<th align="left">Warning</th> 234</tr> 235<tr><td align="left" valign="top"><p>Since Boost version 1.36 the behaviour of this constructor has changed. Now the constructor does not allocate any memory and both capacity and size are set to zero. Also note when inserting an element into a <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code> with zero capacity (e.g. by <code class="computeroutput">push_back(const_reference)</code> or <code class="computeroutput">insert(iterator, value_type)</code>) nothing will be inserted and the size (as well as capacity) remains zero. </p></td></tr> 236</table></div> 237<p> 238</p> 239<div class="note"><table border="0" summary="Note"> 240<tr> 241<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../doc/src/images/note.png"></td> 242<th align="left">Note</th> 243</tr> 244<tr><td align="left" valign="top"><p>You can explicitly set the capacity by calling the <code class="computeroutput">set_capacity(capacity_type)</code> method or you can use the other constructor with the capacity specified. </p></td></tr> 245</table></div> 246<p> 247</p> 248<p><span class="bold"><strong>See Also:</strong></span></p> 249<p><code class="computeroutput">circular_buffer(capacity_type, const allocator_type& alloc)</code>, <code class="computeroutput">set_capacity(capacity_type)</code> </p> 250<p> 251</p> 252<p> 253</p> 254<div class="variablelist"><table border="0" class="variablelist compact"> 255<colgroup> 256<col align="left" valign="top"> 257<col> 258</colgroup> 259<tbody> 260<tr> 261<td><p><span class="term">Parameters:</span></p></td> 262<td><div class="variablelist"><table border="0" class="variablelist compact"> 263<colgroup> 264<col align="left" valign="top"> 265<col> 266</colgroup> 267<tbody><tr> 268<td><p><span class="term"><code class="computeroutput">alloc</code></span></p></td> 269<td><p>The allocator. </p></td> 270</tr></tbody> 271</table></div></td> 272</tr> 273<tr> 274<td><p><span class="term">Postconditions:</span></p></td> 275<td><p><code class="computeroutput">capacity() == 0 && size() == 0</code> </p></td> 276</tr> 277<tr> 278<td><p><span class="term">Throws:</span></p></td> 279<td>Nothing. </td> 280</tr> 281</tbody> 282</table></div> 283</li> 284<li class="listitem"> 285<pre class="literallayout"><span class="keyword">explicit</span> <a name="idm45227212590048-bb"></a><span class="identifier">circular_buffer</span><span class="special">(</span><span class="identifier">capacity_type</span> buffer_capacity<span class="special">,</span> 286 <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 <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code> with the specified capacity. <p> 287 288 289</p> 290<p><b>Complexity. </b>Constant. </p> 291<p> 292</p> 293<div class="variablelist"><table border="0" class="variablelist compact"> 294<colgroup> 295<col align="left" valign="top"> 296<col> 297</colgroup> 298<tbody> 299<tr> 300<td><p><span class="term">Parameters:</span></p></td> 301<td><div class="variablelist"><table border="0" class="variablelist compact"> 302<colgroup> 303<col align="left" valign="top"> 304<col> 305</colgroup> 306<tbody> 307<tr> 308<td><p><span class="term"><code class="computeroutput">alloc</code></span></p></td> 309<td><p>The allocator. </p></td> 310</tr> 311<tr> 312<td><p><span class="term"><code class="computeroutput">buffer_capacity</code></span></p></td> 313<td><p>The maximum number of elements which can be stored in the <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> 314</tr> 315</tbody> 316</table></div></td> 317</tr> 318<tr> 319<td><p><span class="term">Postconditions:</span></p></td> 320<td><p><code class="computeroutput">capacity() == buffer_capacity && size() == 0</code> </p></td> 321</tr> 322<tr> 323<td><p><span class="term">Throws:</span></p></td> 324<td>An allocation error if memory is exhausted (<code class="computeroutput">std::bad_alloc</code> if the standard allocator is used). </td> 325</tr> 326</tbody> 327</table></div> 328</li> 329<li class="listitem"> 330<pre class="literallayout"><a name="idm45227212581424-bb"></a><span class="identifier">circular_buffer</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> 331 <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 <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code> with the specified capacity and filled with <code class="computeroutput">n</code> copies of <code class="computeroutput">item</code>. <p> 332 333 334</p> 335<p><b>Complexity. </b>Linear (in the <code class="computeroutput">n</code>). </p> 336<p> 337</p> 338<div class="variablelist"><table border="0" class="variablelist compact"> 339<colgroup> 340<col align="left" valign="top"> 341<col> 342</colgroup> 343<tbody> 344<tr> 345<td><p><span class="term">Parameters:</span></p></td> 346<td><div class="variablelist"><table border="0" class="variablelist compact"> 347<colgroup> 348<col align="left" valign="top"> 349<col> 350</colgroup> 351<tbody> 352<tr> 353<td><p><span class="term"><code class="computeroutput">alloc</code></span></p></td> 354<td><p>The allocator. </p></td> 355</tr> 356<tr> 357<td><p><span class="term"><code class="computeroutput">item</code></span></p></td> 358<td><p>The element the created <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code> will be filled with. </p></td> 359</tr> 360<tr> 361<td><p><span class="term"><code class="computeroutput">n</code></span></p></td> 362<td><p>The number of elements the created <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code> will be filled with. </p></td> 363</tr> 364</tbody> 365</table></div></td> 366</tr> 367<tr> 368<td><p><span class="term">Postconditions:</span></p></td> 369<td><p><code class="computeroutput">capacity() == n && full() && (*this)[0] == item && (*this)[1] == item && ... && (*this)[n - 1] == item </code> </p></td> 370</tr> 371<tr> 372<td><p><span class="term">Throws:</span></p></td> 373<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> 374</tr> 375</tbody> 376</table></div> 377</li> 378<li class="listitem"> 379<pre class="literallayout"><a name="idm45227212569264-bb"></a><span class="identifier">circular_buffer</span><span class="special">(</span><span class="identifier">capacity_type</span> buffer_capacity<span class="special">,</span> <span class="identifier">size_type</span> n<span class="special">,</span> 380 <span class="identifier">param_value_type</span> item<span class="special">,</span> 381 <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 <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code> with the specified capacity and filled with <code class="computeroutput">n</code> copies of <code class="computeroutput">item</code>. <p> 382 383 384 385</p> 386<p><b>Complexity. </b>Linear (in the <code class="computeroutput">n</code>). </p> 387<p> 388</p> 389<div class="variablelist"><table border="0" class="variablelist compact"> 390<colgroup> 391<col align="left" valign="top"> 392<col> 393</colgroup> 394<tbody> 395<tr> 396<td><p><span class="term">Parameters:</span></p></td> 397<td><div class="variablelist"><table border="0" class="variablelist compact"> 398<colgroup> 399<col align="left" valign="top"> 400<col> 401</colgroup> 402<tbody> 403<tr> 404<td><p><span class="term"><code class="computeroutput">alloc</code></span></p></td> 405<td><p>The allocator. </p></td> 406</tr> 407<tr> 408<td><p><span class="term"><code class="computeroutput">buffer_capacity</code></span></p></td> 409<td><p>The capacity of the created <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> 410</tr> 411<tr> 412<td><p><span class="term"><code class="computeroutput">item</code></span></p></td> 413<td><p>The element the created <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code> will be filled with. </p></td> 414</tr> 415<tr> 416<td><p><span class="term"><code class="computeroutput">n</code></span></p></td> 417<td><p>The number of elements the created <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code> will be filled with. </p></td> 418</tr> 419</tbody> 420</table></div></td> 421</tr> 422<tr> 423<td><p><span class="term">Requires:</span></p></td> 424<td><p><code class="computeroutput">buffer_capacity >= n</code> </p></td> 425</tr> 426<tr> 427<td><p><span class="term">Postconditions:</span></p></td> 428<td><p><code class="computeroutput">capacity() == buffer_capacity && size() == n && (*this)[0] == item && (*this)[1] == item && ... && (*this)[n - 1] == item</code> </p></td> 429</tr> 430<tr> 431<td><p><span class="term">Throws:</span></p></td> 432<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> 433</tr> 434</tbody> 435</table></div> 436</li> 437<li class="listitem"> 438<pre class="literallayout"><a name="idm45227212554240-bb"></a><span class="identifier">circular_buffer</span><span class="special">(</span><span class="keyword">const</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> 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_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code>. 439 440 441</p> 442<p><b>Complexity. </b>Linear (in the size of <code class="computeroutput">cb</code>). </p> 443<p> 444</p> 445<div class="variablelist"><table border="0" class="variablelist compact"> 446<colgroup> 447<col align="left" valign="top"> 448<col> 449</colgroup> 450<tbody> 451<tr> 452<td><p><span class="term">Parameters:</span></p></td> 453<td><div class="variablelist"><table border="0" class="variablelist compact"> 454<colgroup> 455<col align="left" valign="top"> 456<col> 457</colgroup> 458<tbody><tr> 459<td><p><span class="term"><code class="computeroutput">cb</code></span></p></td> 460<td><p>The <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code> to be copied. </p></td> 461</tr></tbody> 462</table></div></td> 463</tr> 464<tr> 465<td><p><span class="term">Postconditions:</span></p></td> 466<td><p><code class="computeroutput">*this == cb</code> </p></td> 467</tr> 468<tr> 469<td><p><span class="term">Throws:</span></p></td> 470<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> 471</tr> 472</tbody> 473</table></div> 474</li> 475<li class="listitem"> 476<pre class="literallayout"><a name="idm45227212546000-bb"></a><span class="identifier">circular_buffer</span><span class="special">(</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> 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_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code> from <code class="computeroutput">cb</code>, leaving <code class="computeroutput">cb</code> empty. 477 478 479 480</p> 481<p><b>Constant. </b></p> 482<p> 483</p> 484<div class="variablelist"><table border="0" class="variablelist compact"> 485<colgroup> 486<col align="left" valign="top"> 487<col> 488</colgroup> 489<tbody> 490<tr> 491<td><p><span class="term">Parameters:</span></p></td> 492<td><div class="variablelist"><table border="0" class="variablelist compact"> 493<colgroup> 494<col align="left" valign="top"> 495<col> 496</colgroup> 497<tbody><tr> 498<td><p><span class="term"><code class="computeroutput">cb</code></span></p></td> 499<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> 500</tr></tbody> 501</table></div></td> 502</tr> 503<tr> 504<td><p><span class="term">Requires:</span></p></td> 505<td><p>C++ compiler with rvalue references support. </p></td> 506</tr> 507<tr> 508<td><p><span class="term">Postconditions:</span></p></td> 509<td><p><code class="computeroutput">cb.empty()</code> </p></td> 510</tr> 511<tr> 512<td><p><span class="term">Throws:</span></p></td> 513<td>Nothing. </td> 514</tr> 515</tbody> 516</table></div> 517</li> 518<li class="listitem"> 519<pre class="literallayout"><span class="keyword">template</span><span class="special"><</span><span class="keyword">typename</span> InputIterator<span class="special">></span> 520 <a name="idm45227212537856-bb"></a><span class="identifier">circular_buffer</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> 521 <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 <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code> filled with a copy of the range. <p> 522 523 524 525</p> 526<p><b>Complexity. </b>Linear (in the <code class="computeroutput">std::distance(first, last)</code>). </p> 527<p> 528</p> 529<div class="variablelist"><table border="0" class="variablelist compact"> 530<colgroup> 531<col align="left" valign="top"> 532<col> 533</colgroup> 534<tbody> 535<tr> 536<td><p><span class="term">Parameters:</span></p></td> 537<td><div class="variablelist"><table border="0" class="variablelist compact"> 538<colgroup> 539<col align="left" valign="top"> 540<col> 541</colgroup> 542<tbody> 543<tr> 544<td><p><span class="term"><code class="computeroutput">alloc</code></span></p></td> 545<td><p>The allocator. </p></td> 546</tr> 547<tr> 548<td><p><span class="term"><code class="computeroutput">first</code></span></p></td> 549<td><p>The beginning of the range to be copied. </p></td> 550</tr> 551<tr> 552<td><p><span class="term"><code class="computeroutput">last</code></span></p></td> 553<td><p>The end of the range to be copied. </p></td> 554</tr> 555</tbody> 556</table></div></td> 557</tr> 558<tr> 559<td><p><span class="term">Requires:</span></p></td> 560<td><p>Valid range <code class="computeroutput">[first, last)</code>.<br> 561 <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> 562</tr> 563<tr> 564<td><p><span class="term">Postconditions:</span></p></td> 565<td><p><code class="computeroutput">capacity() == std::distance(first, last) && full() && (*this)[0]== *first && (*this)[1] == *(first + 1) && ... && (*this)[std::distance(first, last) - 1] == *(last - 1)</code> </p></td> 566</tr> 567<tr> 568<td><p><span class="term">Throws:</span></p></td> 569<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> 570</tr> 571</tbody> 572</table></div> 573</li> 574<li class="listitem"> 575<pre class="literallayout"><span class="keyword">template</span><span class="special"><</span><span class="keyword">typename</span> InputIterator<span class="special">></span> 576 <a name="idm45227212524368-bb"></a><span class="identifier">circular_buffer</span><span class="special">(</span><span class="identifier">capacity_type</span> buffer_capacity<span class="special">,</span> <span class="identifier">InputIterator</span> first<span class="special">,</span> 577 <span class="identifier">InputIterator</span> last<span class="special">,</span> 578 <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 <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code> with the specified capacity and filled with a copy of the range. <p> 579 580 581 582</p> 583<p><b>Complexity. </b>Linear (in <code class="computeroutput">std::distance(first, last)</code>; in <code class="computeroutput">min[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> 584<p> 585</p> 586<div class="variablelist"><table border="0" class="variablelist compact"> 587<colgroup> 588<col align="left" valign="top"> 589<col> 590</colgroup> 591<tbody> 592<tr> 593<td><p><span class="term">Parameters:</span></p></td> 594<td><div class="variablelist"><table border="0" class="variablelist compact"> 595<colgroup> 596<col align="left" valign="top"> 597<col> 598</colgroup> 599<tbody> 600<tr> 601<td><p><span class="term"><code class="computeroutput">alloc</code></span></p></td> 602<td><p>The allocator. </p></td> 603</tr> 604<tr> 605<td><p><span class="term"><code class="computeroutput">buffer_capacity</code></span></p></td> 606<td><p>The capacity of the created <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> 607</tr> 608<tr> 609<td><p><span class="term"><code class="computeroutput">first</code></span></p></td> 610<td><p>The beginning of the range to be copied. </p></td> 611</tr> 612<tr> 613<td><p><span class="term"><code class="computeroutput">last</code></span></p></td> 614<td><p>The end of the range to be copied. </p></td> 615</tr> 616</tbody> 617</table></div></td> 618</tr> 619<tr> 620<td><p><span class="term">Requires:</span></p></td> 621<td><p>Valid range <code class="computeroutput">[first, last)</code>.<br> 622 <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> 623</tr> 624<tr> 625<td><p><span class="term">Postconditions:</span></p></td> 626<td><p><code class="computeroutput">capacity() == buffer_capacity && size() <= std::distance(first, last) && (*this)[0]== *(last - buffer_capacity) && (*this)[1] == *(last - buffer_capacity + 1) && ... && (*this)[buffer_capacity - 1] == *(last - 1)</code><br> 627<br> 628 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">buffer_capacity</code> then only elements from the range <code class="computeroutput">[last - buffer_capacity, last)</code> will be copied. </p></td> 629</tr> 630<tr> 631<td><p><span class="term">Throws:</span></p></td> 632<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> 633</tr> 634</tbody> 635</table></div> 636</li> 637<li class="listitem"> 638<pre class="literallayout"><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> 639<a name="idm45227212496912-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_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> 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_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code> to become a copy of the specified <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code>. 640 641 642</p> 643<p><b>Exception Safety. </b>Strong. </p> 644<p> 645</p> 646<p><b>Iterator Invalidation. </b>Invalidates all iterators pointing to this <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code> (except iterators equal to <code class="computeroutput">end()</code>). </p> 647<p> 648</p> 649<p><b>Complexity. </b>Linear (in the size of <code class="computeroutput">cb</code>). </p> 650<p> 651</p> 652<p><span class="bold"><strong>See Also:</strong></span></p> 653<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> 654<p> 655</p> 656<p> 657</p> 658<div class="variablelist"><table border="0" class="variablelist compact"> 659<colgroup> 660<col align="left" valign="top"> 661<col> 662</colgroup> 663<tbody> 664<tr> 665<td><p><span class="term">Parameters:</span></p></td> 666<td><div class="variablelist"><table border="0" class="variablelist compact"> 667<colgroup> 668<col align="left" valign="top"> 669<col> 670</colgroup> 671<tbody><tr> 672<td><p><span class="term"><code class="computeroutput">cb</code></span></p></td> 673<td><p>The <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code> to be copied. </p></td> 674</tr></tbody> 675</table></div></td> 676</tr> 677<tr> 678<td><p><span class="term">Postconditions:</span></p></td> 679<td><p><code class="computeroutput">*this == cb</code> </p></td> 680</tr> 681<tr> 682<td><p><span class="term">Throws:</span></p></td> 683<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> 684</tr> 685</tbody> 686</table></div> 687</li> 688<li class="listitem"> 689<pre class="literallayout"><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> 690<a name="idm45227212480832-bb"></a><span class="keyword">operator</span><span class="special">=</span><span class="special">(</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> 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> 691 692 693 694</p> 695<p><b>Complexity. </b>Constant. </p> 696<p> 697</p> 698<div class="variablelist"><table border="0" class="variablelist compact"> 699<colgroup> 700<col align="left" valign="top"> 701<col> 702</colgroup> 703<tbody> 704<tr> 705<td><p><span class="term">Parameters:</span></p></td> 706<td><div class="variablelist"><table border="0" class="variablelist compact"> 707<colgroup> 708<col align="left" valign="top"> 709<col> 710</colgroup> 711<tbody><tr> 712<td><p><span class="term"><code class="computeroutput">cb</code></span></p></td> 713<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> 714</tr></tbody> 715</table></div></td> 716</tr> 717<tr> 718<td><p><span class="term">Requires:</span></p></td> 719<td><p>C++ compiler with rvalue references support. </p></td> 720</tr> 721<tr> 722<td><p><span class="term">Postconditions:</span></p></td> 723<td><p><code class="computeroutput">cb.empty()</code> </p></td> 724</tr> 725<tr> 726<td><p><span class="term">Throws:</span></p></td> 727<td>Nothing. </td> 728</tr> 729</tbody> 730</table></div> 731</li> 732<li class="listitem"> 733<pre class="literallayout"><a name="idm45227212505328-bb"></a><span class="special">~</span><span class="identifier">circular_buffer</span><span class="special">(</span><span class="special">)</span><span class="special">;</span></pre>The destructor. <p>Destroys the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code>. 734</p> 735<p><b>Iterator Invalidation. </b>Invalidates all iterators pointing to the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code> (including iterators equal to <code class="computeroutput">end()</code>). </p> 736<p> 737</p> 738<p><b>Complexity. </b>Constant (in the size of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code>) for scalar types; linear for other types. </p> 739<p> 740</p> 741<p><span class="bold"><strong>See Also:</strong></span></p> 742<p><code class="computeroutput">clear()</code> </p> 743<p> 744</p> 745<p> 746</p> 747<div class="variablelist"><table border="0" class="variablelist compact"> 748<colgroup> 749<col align="left" valign="top"> 750<col> 751</colgroup> 752<tbody><tr> 753<td><p><span class="term">Throws:</span></p></td> 754<td>Nothing. </td> 755</tr></tbody> 756</table></div> 757</li> 758</ol></div> 759</div> 760<div class="refsect2"> 761<a name="id-1.3.9.16.3.3.4.6"></a><h3> 762<a name="idm45227213704720-bb"></a><code class="computeroutput">circular_buffer</code> public member functions</h3> 763<div class="orderedlist"><ol class="orderedlist" type="1"> 764<li class="listitem"> 765<pre class="literallayout"><span class="identifier">allocator_type</span> <a name="idm45227213704160-bb"></a><span class="identifier">get_allocator</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 allocator. <p> 766 767</p> 768<p><b>Exception Safety. </b>No-throw. </p> 769<p> 770</p> 771<p><b>Iterator Invalidation. </b>Does not invalidate any iterators. </p> 772<p> 773</p> 774<p><b>Complexity. </b>Constant (in the size of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code>). </p> 775<p> 776</p> 777<p><span class="bold"><strong>See Also:</strong></span></p> 778<p><code class="computeroutput">get_allocator()</code> for obtaining an allocator reference. </p> 779<p> 780</p> 781<p> 782</p> 783<div class="variablelist"><table border="0" class="variablelist compact"> 784<colgroup> 785<col align="left" valign="top"> 786<col> 787</colgroup> 788<tbody> 789<tr> 790<td><p><span class="term">Returns:</span></p></td> 791<td><p>The allocator. </p></td> 792</tr> 793<tr> 794<td><p><span class="term">Throws:</span></p></td> 795<td>Nothing. </td> 796</tr> 797</tbody> 798</table></div> 799</li> 800<li class="listitem"> 801<pre class="literallayout"><span class="identifier">allocator_type</span> <span class="special">&</span> <a name="idm45227213695504-bb"></a><span class="identifier">get_allocator</span><span class="special">(</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span></pre>Get the allocator reference. <p> 802 803</p> 804<p><b>Exception Safety. </b>No-throw. </p> 805<p> 806</p> 807<p><b>Iterator Invalidation. </b>Does not invalidate any iterators. </p> 808<p> 809</p> 810<p><b>Complexity. </b>Constant (in the size of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code>). </p> 811<p> 812</p> 813<div class="note"><table border="0" summary="Note"> 814<tr> 815<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../doc/src/images/note.png"></td> 816<th align="left">Note</th> 817</tr> 818<tr><td align="left" valign="top"><p>This method was added in order to optimize obtaining of the allocator with a state, although use of stateful allocators in STL is discouraged. </p></td></tr> 819</table></div> 820<p> 821</p> 822<p><span class="bold"><strong>See Also:</strong></span></p> 823<p><code class="computeroutput">get_allocator() const</code> </p> 824<p> 825</p> 826<p> 827</p> 828<div class="variablelist"><table border="0" class="variablelist compact"> 829<colgroup> 830<col align="left" valign="top"> 831<col> 832</colgroup> 833<tbody> 834<tr> 835<td><p><span class="term">Returns:</span></p></td> 836<td><p>A reference to the allocator. </p></td> 837</tr> 838<tr> 839<td><p><span class="term">Throws:</span></p></td> 840<td>Nothing. </td> 841</tr> 842</tbody> 843</table></div> 844</li> 845<li class="listitem"> 846<pre class="literallayout"><span class="identifier">iterator</span> <a name="idm45227213686000-bb"></a><span class="identifier">begin</span><span class="special">(</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span></pre>Get the iterator pointing to the beginning of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code>. <p> 847 848</p> 849<p><b>Exception Safety. </b>No-throw. </p> 850<p> 851</p> 852<p><b>Iterator Invalidation. </b>Does not invalidate any iterators. </p> 853<p> 854</p> 855<p><b>Complexity. </b>Constant (in the size of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code>). </p> 856<p> 857</p> 858<p><span class="bold"><strong>See Also:</strong></span></p> 859<p><code class="computeroutput">end()</code>, <code class="computeroutput">rbegin()</code>, <code class="computeroutput">rend()</code> </p> 860<p> 861</p> 862<p> 863</p> 864<div class="variablelist"><table border="0" class="variablelist compact"> 865<colgroup> 866<col align="left" valign="top"> 867<col> 868</colgroup> 869<tbody> 870<tr> 871<td><p><span class="term">Returns:</span></p></td> 872<td><p>A random access iterator pointing to the first element of the <code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code>. If the <code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code> is empty it returns an iterator equal to the one returned by <code class="computeroutput">end()</code>. </p></td> 873</tr> 874<tr> 875<td><p><span class="term">Throws:</span></p></td> 876<td>Nothing. </td> 877</tr> 878</tbody> 879</table></div> 880</li> 881<li class="listitem"> 882<pre class="literallayout"><span class="identifier">iterator</span> <a name="idm45227213673504-bb"></a><span class="identifier">end</span><span class="special">(</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span></pre>Get the iterator pointing to the end of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code>. <p> 883 884</p> 885<p><b>Exception Safety. </b>No-throw. </p> 886<p> 887</p> 888<p><b>Iterator Invalidation. </b>Does not invalidate any iterators. </p> 889<p> 890</p> 891<p><b>Complexity. </b>Constant (in the size of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code>). </p> 892<p> 893</p> 894<p><span class="bold"><strong>See Also:</strong></span></p> 895<p><code class="computeroutput">begin()</code>, <code class="computeroutput">rbegin()</code>, <code class="computeroutput">rend()</code> </p> 896<p> 897</p> 898<p> 899</p> 900<div class="variablelist"><table border="0" class="variablelist compact"> 901<colgroup> 902<col align="left" valign="top"> 903<col> 904</colgroup> 905<tbody> 906<tr> 907<td><p><span class="term">Returns:</span></p></td> 908<td><p>A random access iterator pointing to the element "one behind" the last element of the <code class="computeroutput"> <a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code>. If the <code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code> is empty it returns an iterator equal to the one returned by <code class="computeroutput">begin()</code>. </p></td> 909</tr> 910<tr> 911<td><p><span class="term">Throws:</span></p></td> 912<td>Nothing. </td> 913</tr> 914</tbody> 915</table></div> 916</li> 917<li class="listitem"> 918<pre class="literallayout"><span class="identifier">const_iterator</span> <a name="idm45227213660672-bb"></a><span class="identifier">begin</span><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span></pre>Get the const iterator pointing to the beginning of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code>. <p> 919 920</p> 921<p><b>Exception Safety. </b>No-throw. </p> 922<p> 923</p> 924<p><b>Iterator Invalidation. </b>Does not invalidate any iterators. </p> 925<p> 926</p> 927<p><b>Complexity. </b>Constant (in the size of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code>). </p> 928<p> 929</p> 930<p><span class="bold"><strong>See Also:</strong></span></p> 931<p><code class="computeroutput">end() const</code>, <code class="computeroutput">rbegin() const</code>, <code class="computeroutput">rend() const</code> </p> 932<p> 933</p> 934<p> 935</p> 936<div class="variablelist"><table border="0" class="variablelist compact"> 937<colgroup> 938<col align="left" valign="top"> 939<col> 940</colgroup> 941<tbody> 942<tr> 943<td><p><span class="term">Returns:</span></p></td> 944<td><p>A const random access iterator pointing to the first element of the <code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code>. If the <code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code> is empty it returns an iterator equal to the one returned by <code class="computeroutput">end() const</code>. </p></td> 945</tr> 946<tr> 947<td><p><span class="term">Throws:</span></p></td> 948<td>Nothing. </td> 949</tr> 950</tbody> 951</table></div> 952</li> 953<li class="listitem"><pre class="literallayout"><span class="identifier">const_iterator</span> <a name="idm45227213648000-bb"></a><span class="identifier">cbegin</span><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span></pre></li> 954<li class="listitem"> 955<pre class="literallayout"><span class="identifier">const_iterator</span> <a name="idm45227213646880-bb"></a><span class="identifier">end</span><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span></pre>Get the const iterator pointing to the end of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code>. <p> 956 957</p> 958<p><b>Exception Safety. </b>No-throw. </p> 959<p> 960</p> 961<p><b>Iterator Invalidation. </b>Does not invalidate any iterators. </p> 962<p> 963</p> 964<p><b>Complexity. </b>Constant (in the size of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code>). </p> 965<p> 966</p> 967<p><span class="bold"><strong>See Also:</strong></span></p> 968<p><code class="computeroutput">begin() const</code>, <code class="computeroutput">rbegin() const</code>, <code class="computeroutput">rend() const</code> </p> 969<p> 970</p> 971<p> 972</p> 973<div class="variablelist"><table border="0" class="variablelist compact"> 974<colgroup> 975<col align="left" valign="top"> 976<col> 977</colgroup> 978<tbody> 979<tr> 980<td><p><span class="term">Returns:</span></p></td> 981<td><p>A const random access iterator pointing to the element "one behind" the last element of the <code class="computeroutput"> <a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code>. If the <code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code> is empty it returns an iterator equal to the one returned by <code class="computeroutput">begin() const</code> const. </p></td> 982</tr> 983<tr> 984<td><p><span class="term">Throws:</span></p></td> 985<td>Nothing. </td> 986</tr> 987</tbody> 988</table></div> 989</li> 990<li class="listitem"><pre class="literallayout"><span class="identifier">const_iterator</span> <a name="idm45227213634032-bb"></a><span class="identifier">cend</span><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span></pre></li> 991<li class="listitem"> 992<pre class="literallayout"><span class="identifier">reverse_iterator</span> <a name="idm45227213632912-bb"></a><span class="identifier">rbegin</span><span class="special">(</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span></pre>Get the iterator pointing to the beginning of the "reversed" <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code>. <p> 993 994</p> 995<p><b>Exception Safety. </b>No-throw. </p> 996<p> 997</p> 998<p><b>Iterator Invalidation. </b>Does not invalidate any iterators. </p> 999<p> 1000</p> 1001<p><b>Complexity. </b>Constant (in the size of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code>). </p> 1002<p> 1003</p> 1004<p><span class="bold"><strong>See Also:</strong></span></p> 1005<p><code class="computeroutput">rend()</code>, <code class="computeroutput">begin()</code>, <code class="computeroutput">end()</code> </p> 1006<p> 1007</p> 1008<p> 1009</p> 1010<div class="variablelist"><table border="0" class="variablelist compact"> 1011<colgroup> 1012<col align="left" valign="top"> 1013<col> 1014</colgroup> 1015<tbody> 1016<tr> 1017<td><p><span class="term">Returns:</span></p></td> 1018<td><p>A reverse random access iterator pointing to the last element of the <code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code>. If the <code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code> is empty it returns an iterator equal to the one returned by <code class="computeroutput">rend()</code>. </p></td> 1019</tr> 1020<tr> 1021<td><p><span class="term">Throws:</span></p></td> 1022<td>Nothing. </td> 1023</tr> 1024</tbody> 1025</table></div> 1026</li> 1027<li class="listitem"> 1028<pre class="literallayout"><span class="identifier">reverse_iterator</span> <a name="idm45227213620240-bb"></a><span class="identifier">rend</span><span class="special">(</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span></pre>Get the iterator pointing to the end of the "reversed" <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code>. <p> 1029 1030</p> 1031<p><b>Exception Safety. </b>No-throw. </p> 1032<p> 1033</p> 1034<p><b>Iterator Invalidation. </b>Does not invalidate any iterators. </p> 1035<p> 1036</p> 1037<p><b>Complexity. </b>Constant (in the size of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code>). </p> 1038<p> 1039</p> 1040<p><span class="bold"><strong>See Also:</strong></span></p> 1041<p><code class="computeroutput">rbegin()</code>, <code class="computeroutput">begin()</code>, <code class="computeroutput">end()</code> </p> 1042<p> 1043</p> 1044<p> 1045</p> 1046<div class="variablelist"><table border="0" class="variablelist compact"> 1047<colgroup> 1048<col align="left" valign="top"> 1049<col> 1050</colgroup> 1051<tbody> 1052<tr> 1053<td><p><span class="term">Returns:</span></p></td> 1054<td><p>A reverse random access iterator pointing to the element "one before" the first element of the <code class="computeroutput"> <a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code>. If the <code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code> is empty it returns an iterator equal to the one returned by <code class="computeroutput">rbegin()</code>. </p></td> 1055</tr> 1056<tr> 1057<td><p><span class="term">Throws:</span></p></td> 1058<td>Nothing. </td> 1059</tr> 1060</tbody> 1061</table></div> 1062</li> 1063<li class="listitem"> 1064<pre class="literallayout"><span class="identifier">const_reverse_iterator</span> <a name="idm45227213607392-bb"></a><span class="identifier">rbegin</span><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span></pre>Get the const iterator pointing to the beginning of the "reversed" <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code>. <p> 1065 1066</p> 1067<p><b>Exception Safety. </b>No-throw. </p> 1068<p> 1069</p> 1070<p><b>Iterator Invalidation. </b>Does not invalidate any iterators. </p> 1071<p> 1072</p> 1073<p><b>Complexity. </b>Constant (in the size of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code>). </p> 1074<p> 1075</p> 1076<p><span class="bold"><strong>See Also:</strong></span></p> 1077<p><code class="computeroutput">rend() const</code>, <code class="computeroutput">begin() const</code>, <code class="computeroutput">end() const</code> </p> 1078<p> 1079</p> 1080<p> 1081</p> 1082<div class="variablelist"><table border="0" class="variablelist compact"> 1083<colgroup> 1084<col align="left" valign="top"> 1085<col> 1086</colgroup> 1087<tbody> 1088<tr> 1089<td><p><span class="term">Returns:</span></p></td> 1090<td><p>A const reverse random access iterator pointing to the last element of the <code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code>. If the <code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code> is empty it returns an iterator equal to the one returned by <code class="computeroutput">rend() const</code>. </p></td> 1091</tr> 1092<tr> 1093<td><p><span class="term">Throws:</span></p></td> 1094<td>Nothing. </td> 1095</tr> 1096</tbody> 1097</table></div> 1098</li> 1099<li class="listitem"> 1100<pre class="literallayout"><span class="identifier">const_reverse_iterator</span> <a name="idm45227213594704-bb"></a><span class="identifier">rend</span><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span></pre>Get the const iterator pointing to the end of the "reversed" <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code>. <p> 1101 1102</p> 1103<p><b>Exception Safety. </b>No-throw. </p> 1104<p> 1105</p> 1106<p><b>Iterator Invalidation. </b>Does not invalidate any iterators. </p> 1107<p> 1108</p> 1109<p><b>Complexity. </b>Constant (in the size of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code>). </p> 1110<p> 1111</p> 1112<p><span class="bold"><strong>See Also:</strong></span></p> 1113<p><code class="computeroutput">rbegin() const</code>, <code class="computeroutput">begin() const</code>, <code class="computeroutput">end() const</code> </p> 1114<p> 1115</p> 1116<p> 1117</p> 1118<div class="variablelist"><table border="0" class="variablelist compact"> 1119<colgroup> 1120<col align="left" valign="top"> 1121<col> 1122</colgroup> 1123<tbody> 1124<tr> 1125<td><p><span class="term">Returns:</span></p></td> 1126<td><p>A const reverse random access iterator pointing to the element "one before" the first element of the <code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code>. If the <code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code> is empty it returns an iterator equal to the one returned by <code class="computeroutput">rbegin() const</code>. </p></td> 1127</tr> 1128<tr> 1129<td><p><span class="term">Throws:</span></p></td> 1130<td>Nothing. </td> 1131</tr> 1132</tbody> 1133</table></div> 1134</li> 1135<li class="listitem"> 1136<pre class="literallayout"><span class="identifier">reference</span> <a name="idm45227213582000-bb"></a><span class="keyword">operator</span> <span class="special">[</span><span class="special">]</span><span class="special">(</span><span class="identifier">size_type</span> index<span class="special">)</span><span class="special">;</span></pre>Get the element at the <code class="computeroutput">index</code> position. <p> 1137 1138 1139 1140</p> 1141<p><b>Exception Safety. </b>No-throw. </p> 1142<p> 1143</p> 1144<p><b>Iterator Invalidation. </b>Does not invalidate any iterators. </p> 1145<p> 1146</p> 1147<p><b>Complexity. </b>Constant (in the size of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code>). </p> 1148<p> 1149</p> 1150<p><span class="bold"><strong>See Also:</strong></span></p> 1151<p><code class="computeroutput">at()</code> </p> 1152<p> 1153</p> 1154<p> 1155</p> 1156<div class="variablelist"><table border="0" class="variablelist compact"> 1157<colgroup> 1158<col align="left" valign="top"> 1159<col> 1160</colgroup> 1161<tbody> 1162<tr> 1163<td><p><span class="term">Parameters:</span></p></td> 1164<td><div class="variablelist"><table border="0" class="variablelist compact"> 1165<colgroup> 1166<col align="left" valign="top"> 1167<col> 1168</colgroup> 1169<tbody><tr> 1170<td><p><span class="term"><code class="computeroutput">index</code></span></p></td> 1171<td><p>The position of the element. </p></td> 1172</tr></tbody> 1173</table></div></td> 1174</tr> 1175<tr> 1176<td><p><span class="term">Requires:</span></p></td> 1177<td><p><code class="computeroutput">0 <= index && index < size()</code> </p></td> 1178</tr> 1179<tr> 1180<td><p><span class="term">Returns:</span></p></td> 1181<td><p>A reference to the element at the <code class="computeroutput">index</code> position. </p></td> 1182</tr> 1183<tr> 1184<td><p><span class="term">Throws:</span></p></td> 1185<td>Nothing. </td> 1186</tr> 1187</tbody> 1188</table></div> 1189</li> 1190<li class="listitem"> 1191<pre class="literallayout"><span class="identifier">const_reference</span> <a name="idm45227213570720-bb"></a><span class="keyword">operator</span> <span class="special">[</span><span class="special">]</span><span class="special">(</span><span class="identifier">size_type</span> index<span class="special">)</span> <span class="keyword">const</span><span class="special">;</span></pre>Get the element at the <code class="computeroutput">index</code> position. <p> 1192 1193 1194 1195</p> 1196<p><b>Exception Safety. </b>No-throw. </p> 1197<p> 1198</p> 1199<p><b>Iterator Invalidation. </b>Does not invalidate any iterators. </p> 1200<p> 1201</p> 1202<p><b>Complexity. </b>Constant (in the size of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code>). </p> 1203<p> 1204</p> 1205<p><span class="bold"><strong>See Also:</strong></span></p> 1206<p><code class="computeroutput">at() const </code> </p> 1207<p> 1208</p> 1209<p> 1210</p> 1211<div class="variablelist"><table border="0" class="variablelist compact"> 1212<colgroup> 1213<col align="left" valign="top"> 1214<col> 1215</colgroup> 1216<tbody> 1217<tr> 1218<td><p><span class="term">Parameters:</span></p></td> 1219<td><div class="variablelist"><table border="0" class="variablelist compact"> 1220<colgroup> 1221<col align="left" valign="top"> 1222<col> 1223</colgroup> 1224<tbody><tr> 1225<td><p><span class="term"><code class="computeroutput">index</code></span></p></td> 1226<td><p>The position of the element. </p></td> 1227</tr></tbody> 1228</table></div></td> 1229</tr> 1230<tr> 1231<td><p><span class="term">Requires:</span></p></td> 1232<td><p><code class="computeroutput">0 <= index && index < size()</code> </p></td> 1233</tr> 1234<tr> 1235<td><p><span class="term">Returns:</span></p></td> 1236<td><p>A const reference to the element at the <code class="computeroutput">index</code> position. </p></td> 1237</tr> 1238<tr> 1239<td><p><span class="term">Throws:</span></p></td> 1240<td>Nothing. </td> 1241</tr> 1242</tbody> 1243</table></div> 1244</li> 1245<li class="listitem"> 1246<pre class="literallayout"><span class="identifier">reference</span> <a name="idm45227213559152-bb"></a><span class="identifier">at</span><span class="special">(</span><span class="identifier">size_type</span> index<span class="special">)</span><span class="special">;</span></pre>Get the element at the <code class="computeroutput">index</code> position. <p> 1247 1248 1249</p> 1250<p><b>Exception Safety. </b>Strong. </p> 1251<p> 1252</p> 1253<p><b>Iterator Invalidation. </b>Does not invalidate any iterators. </p> 1254<p> 1255</p> 1256<p><b>Complexity. </b>Constant (in the size of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code>). </p> 1257<p> 1258</p> 1259<p><span class="bold"><strong>See Also:</strong></span></p> 1260<p><code class="computeroutput">operator[] </code> </p> 1261<p> 1262</p> 1263<p> 1264</p> 1265<div class="variablelist"><table border="0" class="variablelist compact"> 1266<colgroup> 1267<col align="left" valign="top"> 1268<col> 1269</colgroup> 1270<tbody> 1271<tr> 1272<td><p><span class="term">Parameters:</span></p></td> 1273<td><div class="variablelist"><table border="0" class="variablelist compact"> 1274<colgroup> 1275<col align="left" valign="top"> 1276<col> 1277</colgroup> 1278<tbody><tr> 1279<td><p><span class="term"><code class="computeroutput">index</code></span></p></td> 1280<td><p>The position of the element. </p></td> 1281</tr></tbody> 1282</table></div></td> 1283</tr> 1284<tr> 1285<td><p><span class="term">Returns:</span></p></td> 1286<td><p>A reference to the element at the <code class="computeroutput">index</code> position. </p></td> 1287</tr> 1288<tr> 1289<td><p><span class="term">Throws:</span></p></td> 1290<td><code>std::out_of_range</code> when the <code class="computeroutput">index</code> is invalid (when <code class="computeroutput">index >= size()</code>). </td> 1291</tr> 1292</tbody> 1293</table></div> 1294</li> 1295<li class="listitem"> 1296<pre class="literallayout"><span class="identifier">const_reference</span> <a name="idm45227213547840-bb"></a><span class="identifier">at</span><span class="special">(</span><span class="identifier">size_type</span> index<span class="special">)</span> <span class="keyword">const</span><span class="special">;</span></pre>Get the element at the <code class="computeroutput">index</code> position. <p> 1297 1298 1299</p> 1300<p><b>Exception Safety. </b>Strong. </p> 1301<p> 1302</p> 1303<p><b>Iterator Invalidation. </b>Does not invalidate any iterators. </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_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code>). </p> 1307<p> 1308</p> 1309<p><span class="bold"><strong>See Also:</strong></span></p> 1310<p><code class="computeroutput">operator[] const </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">index</code></span></p></td> 1330<td><p>The position of the element. </p></td> 1331</tr></tbody> 1332</table></div></td> 1333</tr> 1334<tr> 1335<td><p><span class="term">Returns:</span></p></td> 1336<td><p>A const reference to the element at the <code class="computeroutput">index</code> position. </p></td> 1337</tr> 1338<tr> 1339<td><p><span class="term">Throws:</span></p></td> 1340<td><code>std::out_of_range</code> when the <code class="computeroutput">index</code> is invalid (when <code class="computeroutput">index >= size()</code>). </td> 1341</tr> 1342</tbody> 1343</table></div> 1344</li> 1345<li class="listitem"> 1346<pre class="literallayout"><span class="identifier">reference</span> <a name="idm45227213536240-bb"></a><span class="identifier">front</span><span class="special">(</span><span class="special">)</span><span class="special">;</span></pre>Get the first element. <p> 1347 1348 1349</p> 1350<p><b>Exception Safety. </b>No-throw. </p> 1351<p> 1352</p> 1353<p><b>Iterator Invalidation. </b>Does not invalidate any iterators. </p> 1354<p> 1355</p> 1356<p><b>Complexity. </b>Constant (in the size of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code>). </p> 1357<p> 1358</p> 1359<p><span class="bold"><strong>See Also:</strong></span></p> 1360<p><code class="computeroutput">back()</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">Requires:</span></p></td> 1373<td><p><code class="computeroutput">!empty()</code> </p></td> 1374</tr> 1375<tr> 1376<td><p><span class="term">Returns:</span></p></td> 1377<td><p>A reference to the first element of the <code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code>. </p></td> 1378</tr> 1379<tr> 1380<td><p><span class="term">Throws:</span></p></td> 1381<td>Nothing. </td> 1382</tr> 1383</tbody> 1384</table></div> 1385</li> 1386<li class="listitem"> 1387<pre class="literallayout"><span class="identifier">reference</span> <a name="idm45227213526128-bb"></a><span class="identifier">back</span><span class="special">(</span><span class="special">)</span><span class="special">;</span></pre>Get the last element. <p> 1388 1389 1390</p> 1391<p><b>Exception Safety. </b>No-throw. </p> 1392<p> 1393</p> 1394<p><b>Iterator Invalidation. </b>Does not invalidate any iterators. </p> 1395<p> 1396</p> 1397<p><b>Complexity. </b>Constant (in the size of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code>). </p> 1398<p> 1399</p> 1400<p><span class="bold"><strong>See Also:</strong></span></p> 1401<p><code class="computeroutput">front()</code> </p> 1402<p> 1403</p> 1404<p> 1405</p> 1406<div class="variablelist"><table border="0" class="variablelist compact"> 1407<colgroup> 1408<col align="left" valign="top"> 1409<col> 1410</colgroup> 1411<tbody> 1412<tr> 1413<td><p><span class="term">Requires:</span></p></td> 1414<td><p><code class="computeroutput">!empty()</code> </p></td> 1415</tr> 1416<tr> 1417<td><p><span class="term">Returns:</span></p></td> 1418<td><p>A reference to the last element of the <code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code>. </p></td> 1419</tr> 1420<tr> 1421<td><p><span class="term">Throws:</span></p></td> 1422<td>Nothing. </td> 1423</tr> 1424</tbody> 1425</table></div> 1426</li> 1427<li class="listitem"> 1428<pre class="literallayout"><span class="identifier">const_reference</span> <a name="idm45227213516032-bb"></a><span class="identifier">front</span><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span></pre>Get the first element. <p> 1429 1430 1431</p> 1432<p><b>Exception Safety. </b>No-throw. </p> 1433<p> 1434</p> 1435<p><b>Iterator Invalidation. </b>Does not invalidate any iterators. </p> 1436<p> 1437</p> 1438<p><b>Complexity. </b>Constant (in the size of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code>). </p> 1439<p> 1440</p> 1441<p><span class="bold"><strong>See Also:</strong></span></p> 1442<p><code class="computeroutput">back() const</code> </p> 1443<p> 1444</p> 1445<p> 1446</p> 1447<div class="variablelist"><table border="0" class="variablelist compact"> 1448<colgroup> 1449<col align="left" valign="top"> 1450<col> 1451</colgroup> 1452<tbody> 1453<tr> 1454<td><p><span class="term">Requires:</span></p></td> 1455<td><p><code class="computeroutput">!empty()</code> </p></td> 1456</tr> 1457<tr> 1458<td><p><span class="term">Returns:</span></p></td> 1459<td><p>A const reference to the first element of the <code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code>. </p></td> 1460</tr> 1461<tr> 1462<td><p><span class="term">Throws:</span></p></td> 1463<td>Nothing. </td> 1464</tr> 1465</tbody> 1466</table></div> 1467</li> 1468<li class="listitem"> 1469<pre class="literallayout"><span class="identifier">const_reference</span> <a name="idm45227213505648-bb"></a><span class="identifier">back</span><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span></pre>Get the last element. <p> 1470 1471 1472</p> 1473<p><b>Exception Safety. </b>No-throw. </p> 1474<p> 1475</p> 1476<p><b>Iterator Invalidation. </b>Does not invalidate any iterators. </p> 1477<p> 1478</p> 1479<p><b>Complexity. </b>Constant (in the size of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code>). </p> 1480<p> 1481</p> 1482<p><span class="bold"><strong>See Also:</strong></span></p> 1483<p><code class="computeroutput">front() const</code> </p> 1484<p> 1485</p> 1486<p> 1487</p> 1488<div class="variablelist"><table border="0" class="variablelist compact"> 1489<colgroup> 1490<col align="left" valign="top"> 1491<col> 1492</colgroup> 1493<tbody> 1494<tr> 1495<td><p><span class="term">Requires:</span></p></td> 1496<td><p><code class="computeroutput">!empty()</code> </p></td> 1497</tr> 1498<tr> 1499<td><p><span class="term">Returns:</span></p></td> 1500<td><p>A const reference to the last element of the <code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code>. </p></td> 1501</tr> 1502<tr> 1503<td><p><span class="term">Throws:</span></p></td> 1504<td>Nothing. </td> 1505</tr> 1506</tbody> 1507</table></div> 1508</li> 1509<li class="listitem"> 1510<pre class="literallayout"><span class="identifier">array_range</span> <a name="idm45227213495264-bb"></a><span class="identifier">array_one</span><span class="special">(</span><span class="special">)</span><span class="special">;</span></pre>Get the first continuous array of the internal buffer. <p>This method in combination with <code class="computeroutput">array_two()</code> can be useful when passing the stored data into a legacy C API as an array. Suppose there is a <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code> of capacity 10, containing 7 characters <code class="computeroutput">'a', 'b', ..., 'g'</code> where <code class="computeroutput">buff[0] == 'a'</code>, <code class="computeroutput">buff[1] == 'b'</code>, ... and <code class="computeroutput">buff[6] == 'g'</code>:<br> 1511<br> 1512 <code class="computeroutput">circular_buffer<char> buff(10);</code><br> 1513<br> 1514 The internal representation is often not linear and the state of the internal buffer may look like this:<br> 1515 <br> 1516<code class="computeroutput"> |e|f|g| | | |a|b|c|d|<br> 1517 end ___^<br> 1518 begin _______^</code><br> 1519<br> 1520</p> 1521<p>where <code class="computeroutput">|a|b|c|d|</code> represents the "array one", <code class="computeroutput">|e|f|g|</code> represents the "array two" and <code class="computeroutput">| | | |</code> is a free space.<br> 1522 Now consider a typical C style function for writing data into a file:<br> 1523<br> 1524 <code class="computeroutput">int write(int file_desc, char* buff, int num_bytes);</code><br> 1525<br> 1526 There are two ways how to write the content of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code> into a file. Either relying on <code class="computeroutput">array_one()</code> and <code class="computeroutput">array_two()</code> methods and calling the write function twice:<br> 1527<br> 1528 <code class="computeroutput">array_range ar = buff.array_one();<br> 1529 write(file_desc, ar.first, ar.second);<br> 1530 ar = buff.array_two();<br> 1531 write(file_desc, ar.first, ar.second);</code><br> 1532<br> 1533 Or relying on the <code class="computeroutput">linearize()</code> method:<br> 1534<br> 1535<code class="computeroutput"> write(file_desc, buff.linearize(), buff.size());</code><br> 1536<br> 1537 Since the complexity of <code class="computeroutput">array_one()</code> and <code class="computeroutput">array_two()</code> methods is constant the first option is suitable when calling the write method is "cheap". On the other hand the second option is more suitable when calling the write method is more "expensive" than calling the <code class="computeroutput">linearize()</code> method whose complexity is linear. 1538 1539</p> 1540<p><b>Exception Safety. </b>No-throw. </p> 1541<p> 1542</p> 1543<p><b>Iterator Invalidation. </b>Does not invalidate any iterators. </p> 1544<p> 1545</p> 1546<p><b>Complexity. </b>Constant (in the size of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code>). </p> 1547<p> 1548</p> 1549<div class="warning"><table border="0" summary="Warning"> 1550<tr> 1551<td rowspan="2" align="center" valign="top" width="25"><img alt="[Warning]" src="../../../doc/src/images/warning.png"></td> 1552<th align="left">Warning</th> 1553</tr> 1554<tr><td align="left" valign="top"><p>In general invoking any method which modifies the internal state of the <code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code> may delinearize the internal buffer and invalidate the array ranges returned by <code class="computeroutput">array_one()</code> and <code class="computeroutput">array_two()</code> (and their const versions). </p></td></tr> 1555</table></div> 1556<p> 1557</p> 1558<div class="note"><table border="0" summary="Note"> 1559<tr> 1560<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../doc/src/images/note.png"></td> 1561<th align="left">Note</th> 1562</tr> 1563<tr><td align="left" valign="top"><p>In the case the internal buffer is linear e.g. <code class="computeroutput">|a|b|c|d|e|f|g| | | |</code> the "array one" is represented by <code class="computeroutput">|a|b|c|d|e|f|g|</code> and the "array two" does not exist (the <code class="computeroutput">array_two()</code> method returns an array with the size <code class="computeroutput">0</code>). </p></td></tr> 1564</table></div> 1565<p> 1566</p> 1567<p><span class="bold"><strong>See Also:</strong></span></p> 1568<p><code class="computeroutput">array_two()</code>, <code class="computeroutput">linearize()</code> </p> 1569<p> 1570</p> 1571<p> 1572</p> 1573<div class="variablelist"><table border="0" class="variablelist compact"> 1574<colgroup> 1575<col align="left" valign="top"> 1576<col> 1577</colgroup> 1578<tbody> 1579<tr> 1580<td><p><span class="term">Returns:</span></p></td> 1581<td><p>The array range of the first continuous array of the internal buffer. In the case the <code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code> is empty the size of the returned array is <code class="computeroutput">0</code>. </p></td> 1582</tr> 1583<tr> 1584<td><p><span class="term">Throws:</span></p></td> 1585<td>Nothing. </td> 1586</tr> 1587</tbody> 1588</table></div> 1589</li> 1590<li class="listitem"> 1591<pre class="literallayout"><span class="identifier">array_range</span> <a name="idm45227213461936-bb"></a><span class="identifier">array_two</span><span class="special">(</span><span class="special">)</span><span class="special">;</span></pre>Get the second continuous array of the internal buffer. <p>This method in combination with <code class="computeroutput">array_one()</code> can be useful when passing the stored data into a legacy C API as an array. 1592 1593</p> 1594<p><b>Exception Safety. </b>No-throw. </p> 1595<p> 1596</p> 1597<p><b>Iterator Invalidation. </b>Does not invalidate any iterators. </p> 1598<p> 1599</p> 1600<p><b>Complexity. </b>Constant (in the size of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code>). </p> 1601<p> 1602</p> 1603<p><span class="bold"><strong>See Also:</strong></span></p> 1604<p><code class="computeroutput">array_one()</code> </p> 1605<p> 1606</p> 1607<p> 1608</p> 1609<div class="variablelist"><table border="0" class="variablelist compact"> 1610<colgroup> 1611<col align="left" valign="top"> 1612<col> 1613</colgroup> 1614<tbody> 1615<tr> 1616<td><p><span class="term">Returns:</span></p></td> 1617<td><p>The array range of the second continuous array of the internal buffer. In the case the internal buffer is linear or the <code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code> is empty the size of the returned array is <code class="computeroutput">0</code>. </p></td> 1618</tr> 1619<tr> 1620<td><p><span class="term">Throws:</span></p></td> 1621<td>Nothing. </td> 1622</tr> 1623</tbody> 1624</table></div> 1625</li> 1626<li class="listitem"> 1627<pre class="literallayout"><span class="identifier">const_array_range</span> <a name="idm45227213451552-bb"></a><span class="identifier">array_one</span><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span></pre>Get the first continuous array of the internal buffer. <p>This method in combination with <code class="computeroutput">array_two() const</code> can be useful when passing the stored data into a legacy C API as an array. 1628 1629</p> 1630<p><b>Exception Safety. </b>No-throw. </p> 1631<p> 1632</p> 1633<p><b>Iterator Invalidation. </b>Does not invalidate any iterators. </p> 1634<p> 1635</p> 1636<p><b>Complexity. </b>Constant (in the size of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code>). </p> 1637<p> 1638</p> 1639<p><span class="bold"><strong>See Also:</strong></span></p> 1640<p><code class="computeroutput">array_two() const</code>; <code class="computeroutput">array_one()</code> for more details how to pass data into a legacy C API. </p> 1641<p> 1642</p> 1643<p> 1644</p> 1645<div class="variablelist"><table border="0" class="variablelist compact"> 1646<colgroup> 1647<col align="left" valign="top"> 1648<col> 1649</colgroup> 1650<tbody> 1651<tr> 1652<td><p><span class="term">Returns:</span></p></td> 1653<td><p>The array range of the first continuous array of the internal buffer. In the case the <code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code> is empty the size of the returned array is <code class="computeroutput">0</code>. </p></td> 1654</tr> 1655<tr> 1656<td><p><span class="term">Throws:</span></p></td> 1657<td>Nothing. </td> 1658</tr> 1659</tbody> 1660</table></div> 1661</li> 1662<li class="listitem"> 1663<pre class="literallayout"><span class="identifier">const_array_range</span> <a name="idm45227213440464-bb"></a><span class="identifier">array_two</span><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span></pre>Get the second continuous array of the internal buffer. <p>This method in combination with <code class="computeroutput">array_one() const</code> can be useful when passing the stored data into a legacy C API as an array. 1664 1665</p> 1666<p><b>Exception Safety. </b>No-throw. </p> 1667<p> 1668</p> 1669<p><b>Iterator Invalidation. </b>Does not invalidate any iterators. </p> 1670<p> 1671</p> 1672<p><b>Complexity. </b>Constant (in the size of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code>). </p> 1673<p> 1674</p> 1675<p><span class="bold"><strong>See Also:</strong></span></p> 1676<p><code class="computeroutput">array_one() const</code> </p> 1677<p> 1678</p> 1679<p> 1680</p> 1681<div class="variablelist"><table border="0" class="variablelist compact"> 1682<colgroup> 1683<col align="left" valign="top"> 1684<col> 1685</colgroup> 1686<tbody> 1687<tr> 1688<td><p><span class="term">Returns:</span></p></td> 1689<td><p>The array range of the second continuous array of the internal buffer. In the case the internal buffer is linear or the <code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code> is empty the size of the returned array is <code class="computeroutput">0</code>. </p></td> 1690</tr> 1691<tr> 1692<td><p><span class="term">Throws:</span></p></td> 1693<td>Nothing. </td> 1694</tr> 1695</tbody> 1696</table></div> 1697</li> 1698<li class="listitem"> 1699<pre class="literallayout"><span class="identifier">pointer</span> <a name="idm45227213429808-bb"></a><span class="identifier">linearize</span><span class="special">(</span><span class="special">)</span><span class="special">;</span></pre>Linearize the internal buffer into a continuous array. <p>This method can be useful when passing the stored data into a legacy C API as an array. 1700 1701 1702</p> 1703<p><b>Exception Safety. </b>Basic; no-throw if the operations in the <span class="emphasis"><em>Throws</em></span> section do not throw anything. </p> 1704<p> 1705</p> 1706<p><b>Iterator Invalidation. </b>Invalidates all iterators pointing to the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code> (except iterators equal to <code class="computeroutput">end()</code>); does not invalidate any iterators if the postcondition (the <span class="emphasis"><em>Effect</em></span>) is already met prior calling this method. </p> 1707<p> 1708</p> 1709<p><b>Complexity. </b>Linear (in the size of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code>); constant if the postcondition (the <span class="emphasis"><em>Effect</em></span>) is already met. </p> 1710<p> 1711</p> 1712<div class="warning"><table border="0" summary="Warning"> 1713<tr> 1714<td rowspan="2" align="center" valign="top" width="25"><img alt="[Warning]" src="../../../doc/src/images/warning.png"></td> 1715<th align="left">Warning</th> 1716</tr> 1717<tr><td align="left" valign="top"><p>In general invoking any method which modifies the internal state of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code> may delinearize the internal buffer and invalidate the returned pointer. </p></td></tr> 1718</table></div> 1719<p> 1720</p> 1721<p><span class="bold"><strong>See Also:</strong></span></p> 1722<p><code class="computeroutput">array_one()</code> and <code class="computeroutput">array_two()</code> for the other option how to pass data into a legacy C API; <code class="computeroutput">is_linearized()</code>, <code class="computeroutput">rotate(const_iterator)</code> </p> 1723<p> 1724</p> 1725<p> 1726</p> 1727<div class="variablelist"><table border="0" class="variablelist compact"> 1728<colgroup> 1729<col align="left" valign="top"> 1730<col> 1731</colgroup> 1732<tbody> 1733<tr> 1734<td><p><span class="term">Postconditions:</span></p></td> 1735<td><p><code class="computeroutput">&(*this)[0] < &(*this)[1] < ... < &(*this)[size() - 1]</code> </p></td> 1736</tr> 1737<tr> 1738<td><p><span class="term">Returns:</span></p></td> 1739<td><p>A pointer to the beginning of the array or <code class="computeroutput">0</code> if empty. </p></td> 1740</tr> 1741<tr> 1742<td><p><span class="term">Throws:</span></p></td> 1743<td><a href="circular_buffer/implementation.html#circular_buffer.implementation.exceptions_of_move_if_noexcept_t">Exceptions of move_if_noexcept(T&). </td> 1744</tr> 1745</tbody> 1746</table></div> 1747</li> 1748<li class="listitem"> 1749<pre class="literallayout"><span class="keyword">bool</span> <a name="idm45227213413904-bb"></a><span class="identifier">is_linearized</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_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code> linearized? <p> 1750 1751</p> 1752<p><b>Exception Safety. </b>No-throw. </p> 1753<p> 1754</p> 1755<p><b>Iterator Invalidation. </b>Does not invalidate any iterators. </p> 1756<p> 1757</p> 1758<p><b>Complexity. </b>Constant (in the size of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code>). </p> 1759<p> 1760</p> 1761<p><span class="bold"><strong>See Also:</strong></span></p> 1762<p><code class="computeroutput">linearize()</code>, <code class="computeroutput">array_one()</code>, <code class="computeroutput">array_two()</code> </p> 1763<p> 1764</p> 1765<p> 1766</p> 1767<div class="variablelist"><table border="0" class="variablelist compact"> 1768<colgroup> 1769<col align="left" valign="top"> 1770<col> 1771</colgroup> 1772<tbody> 1773<tr> 1774<td><p><span class="term">Returns:</span></p></td> 1775<td><p><code class="computeroutput">true</code> if the internal buffer is linearized into a continuous array (i.e. the <code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code> meets a condition <code class="computeroutput">&(*this)[0] < &(*this)[1] < ... < &(*this)[size() - 1]</code>); <code class="computeroutput">false</code> otherwise. </p></td> 1776</tr> 1777<tr> 1778<td><p><span class="term">Throws:</span></p></td> 1779<td>Nothing. </td> 1780</tr> 1781</tbody> 1782</table></div> 1783</li> 1784<li class="listitem"> 1785<pre class="literallayout"><span class="keyword">void</span> <a name="idm45227213401392-bb"></a><span class="identifier">rotate</span><span class="special">(</span><span class="identifier">const_iterator</span> new_begin<span class="special">)</span><span class="special">;</span></pre>Rotate elements in the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code>. <p>A more effective implementation of <code class="computeroutput"><a href="https://www.boost.org/sgi/stl/rotate.html" target="_top">std::rotate</a></code>. 1786 1787 1788 1789</p> 1790<p><b>Exception Safety. </b>Basic; no-throw if the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code> is full or <code class="computeroutput">new_begin</code> points to <code class="computeroutput">begin()</code> or if the operations in the <span class="emphasis"><em>Throws</em></span> section do not throw anything. </p> 1791<p> 1792</p> 1793<p><b>Iterator Invalidation. </b>If <code class="computeroutput">m < n</code> invalidates iterators pointing to the last <code class="computeroutput">m</code> elements (<span class="bold"><strong>including</strong></span> <code class="computeroutput">new_begin</code>, but not iterators equal to <code class="computeroutput">end()</code>) else invalidates iterators pointing to the first <code class="computeroutput">n</code> elements; does not invalidate any iterators if the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code> is full. </p> 1794<p> 1795</p> 1796<p><b>Complexity. </b>Linear (in <code class="computeroutput">(std::min)(m, n)</code>); constant if the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code> is full. </p> 1797<p> 1798</p> 1799<p><span class="bold"><strong>See Also:</strong></span></p> 1800<p><code class="computeroutput"><a href="https://www.boost.org/sgi/stl/rotate.html" target="_top">std::rotate</a></code> </p> 1801<p> 1802</p> 1803<p> 1804</p> 1805<div class="variablelist"><table border="0" class="variablelist compact"> 1806<colgroup> 1807<col align="left" valign="top"> 1808<col> 1809</colgroup> 1810<tbody> 1811<tr> 1812<td><p><span class="term">Parameters:</span></p></td> 1813<td><div class="variablelist"><table border="0" class="variablelist compact"> 1814<colgroup> 1815<col align="left" valign="top"> 1816<col> 1817</colgroup> 1818<tbody><tr> 1819<td><p><span class="term"><code class="computeroutput">new_begin</code></span></p></td> 1820<td><p>The new beginning. </p></td> 1821</tr></tbody> 1822</table></div></td> 1823</tr> 1824<tr> 1825<td><p><span class="term">Requires:</span></p></td> 1826<td><p><code class="computeroutput">new_begin</code> is a valid iterator pointing to the <code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code> <span class="bold"><strong>except</strong></span> its end. </p></td> 1827</tr> 1828<tr> 1829<td><p><span class="term">Postconditions:</span></p></td> 1830<td><p>Before calling the method suppose:<br> 1831<br> 1832 <code class="computeroutput">m == std::distance(new_begin, end())</code><br> 1833<code class="computeroutput">n == std::distance(begin(), new_begin)</code> <br> 1834<code class="computeroutput">val_0 == *new_begin, val_1 == *(new_begin + 1), ... val_m == *(new_begin + m)</code><br> 1835 <code class="computeroutput">val_r1 == *(new_begin - 1), val_r2 == *(new_begin - 2), ... val_rn == *(new_begin - n)</code><br> 1836 <br> 1837then after call to the method:<br> 1838<br> 1839 <code class="computeroutput">val_0 == (*this)[0] && val_1 == (*this)[1] && ... && val_m == (*this)[m - 1] && val_r1 == (*this)[m + n - 1] && val_r2 == (*this)[m + n - 2] && ... && val_rn == (*this)[m]</code> </p></td> 1840</tr> 1841<tr> 1842<td><p><span class="term">Throws:</span></p></td> 1843<td>See <a href="../circular_buffer/implementation.html#circular_buffer.implementation.exceptions_of_move_if_noexcept_t" target="_top">Exceptions of move_if_noexcept(T&)</a>. </td> 1844</tr> 1845</tbody> 1846</table></div> 1847</li> 1848<li class="listitem"> 1849<pre class="literallayout"><span class="identifier">size_type</span> <a name="idm45227213375216-bb"></a><span class="identifier">size</span><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span></pre>Get the number of elements currently stored in the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code>. <p> 1850 1851</p> 1852<p><b>Exception Safety. </b>No-throw. </p> 1853<p> 1854</p> 1855<p><b>Iterator Invalidation. </b>Does not invalidate any iterators. </p> 1856<p> 1857</p> 1858<p><b>Complexity. </b>Constant (in the size of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code>). </p> 1859<p> 1860</p> 1861<p><span class="bold"><strong>See Also:</strong></span></p> 1862<p><code class="computeroutput">capacity()</code>, <code class="computeroutput">max_size()</code>, <code class="computeroutput">reserve()</code>, <code class="computeroutput">resize(size_type, const_reference)</code> </p> 1863<p> 1864</p> 1865<p> 1866</p> 1867<div class="variablelist"><table border="0" class="variablelist compact"> 1868<colgroup> 1869<col align="left" valign="top"> 1870<col> 1871</colgroup> 1872<tbody> 1873<tr> 1874<td><p><span class="term">Returns:</span></p></td> 1875<td><p>The number of elements stored in the <code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code>. </p></td> 1876</tr> 1877<tr> 1878<td><p><span class="term">Throws:</span></p></td> 1879<td>Nothing. </td> 1880</tr> 1881</tbody> 1882</table></div> 1883</li> 1884<li class="listitem"> 1885<pre class="literallayout"><span class="identifier">size_type</span> <a name="idm45227213363472-bb"></a><span class="identifier">max_size</span><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span></pre>Get the largest possible size or capacity of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code>. (It depends on allocator's max_size()). <p> 1886 1887</p> 1888<p><b>Exception Safety. </b>No-throw. </p> 1889<p> 1890</p> 1891<p><b>Iterator Invalidation. </b>Does not invalidate any iterators. </p> 1892<p> 1893</p> 1894<p><b>Complexity. </b>Constant (in the size of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code>). </p> 1895<p> 1896</p> 1897<p><span class="bold"><strong>See Also:</strong></span></p> 1898<p><code class="computeroutput">size()</code>, <code class="computeroutput">capacity()</code>, <code class="computeroutput">reserve()</code> </p> 1899<p> 1900</p> 1901<p> 1902</p> 1903<div class="variablelist"><table border="0" class="variablelist compact"> 1904<colgroup> 1905<col align="left" valign="top"> 1906<col> 1907</colgroup> 1908<tbody> 1909<tr> 1910<td><p><span class="term">Returns:</span></p></td> 1911<td><p>The maximum size/capacity the <code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code> can be set to. </p></td> 1912</tr> 1913<tr> 1914<td><p><span class="term">Throws:</span></p></td> 1915<td>Nothing. </td> 1916</tr> 1917</tbody> 1918</table></div> 1919</li> 1920<li class="listitem"> 1921<pre class="literallayout"><span class="keyword">bool</span> <a name="idm45227213352160-bb"></a><span class="identifier">empty</span><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span></pre>Is the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code> empty? <p> 1922 1923</p> 1924<p><b>Exception Safety. </b>No-throw. </p> 1925<p> 1926</p> 1927<p><b>Iterator Invalidation. </b>Does not invalidate any iterators. </p> 1928<p> 1929</p> 1930<p><b>Complexity. </b>Constant (in the size of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code>). </p> 1931<p> 1932</p> 1933<p><span class="bold"><strong>See Also:</strong></span></p> 1934<p><code class="computeroutput">full()</code> </p> 1935<p> 1936</p> 1937<p> 1938</p> 1939<div class="variablelist"><table border="0" class="variablelist compact"> 1940<colgroup> 1941<col align="left" valign="top"> 1942<col> 1943</colgroup> 1944<tbody> 1945<tr> 1946<td><p><span class="term">Returns:</span></p></td> 1947<td><p><code class="computeroutput">true</code> if there are no elements stored in the <code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code>; <code class="computeroutput">false</code> otherwise. </p></td> 1948</tr> 1949<tr> 1950<td><p><span class="term">Throws:</span></p></td> 1951<td>Nothing. </td> 1952</tr> 1953</tbody> 1954</table></div> 1955</li> 1956<li class="listitem"> 1957<pre class="literallayout"><span class="keyword">bool</span> <a name="idm45227213341056-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_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code> full? <p> 1958 1959</p> 1960<p><b>Exception Safety. </b>No-throw. </p> 1961<p> 1962</p> 1963<p><b>Iterator Invalidation. </b>Does not invalidate any iterators. </p> 1964<p> 1965</p> 1966<p><b>Complexity. </b>Constant (in the size of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code>). </p> 1967<p> 1968</p> 1969<p><span class="bold"><strong>See Also:</strong></span></p> 1970<p><code class="computeroutput">empty()</code> </p> 1971<p> 1972</p> 1973<p> 1974</p> 1975<div class="variablelist"><table border="0" class="variablelist compact"> 1976<colgroup> 1977<col align="left" valign="top"> 1978<col> 1979</colgroup> 1980<tbody> 1981<tr> 1982<td><p><span class="term">Returns:</span></p></td> 1983<td><p><code class="computeroutput">true</code> if the number of elements stored in the <code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code> equals the capacity of the <code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code>; <code class="computeroutput">false</code> otherwise. </p></td> 1984</tr> 1985<tr> 1986<td><p><span class="term">Throws:</span></p></td> 1987<td>Nothing. </td> 1988</tr> 1989</tbody> 1990</table></div> 1991</li> 1992<li class="listitem"> 1993<pre class="literallayout"><span class="identifier">size_type</span> <a name="idm45227213329088-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_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code> without overwriting any of already stored elements. <p> 1994 1995</p> 1996<p><b>Exception Safety. </b>No-throw. </p> 1997<p> 1998</p> 1999<p><b>Iterator Invalidation. </b>Does not invalidate any iterators. </p> 2000<p> 2001</p> 2002<p><b>Complexity. </b>Constant (in the size of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code>). </p> 2003<p> 2004</p> 2005<p><span class="bold"><strong>See Also:</strong></span></p> 2006<p><code class="computeroutput">capacity()</code>, <code class="computeroutput">size()</code>, <code class="computeroutput">max_size()</code> </p> 2007<p> 2008</p> 2009<p> 2010</p> 2011<div class="variablelist"><table border="0" class="variablelist compact"> 2012<colgroup> 2013<col align="left" valign="top"> 2014<col> 2015</colgroup> 2016<tbody> 2017<tr> 2018<td><p><span class="term">Returns:</span></p></td> 2019<td><p><code class="computeroutput">capacity() - size()</code> </p></td> 2020</tr> 2021<tr> 2022<td><p><span class="term">Throws:</span></p></td> 2023<td>Nothing. </td> 2024</tr> 2025</tbody> 2026</table></div> 2027</li> 2028<li class="listitem"> 2029<pre class="literallayout"><span class="identifier">capacity_type</span> <a name="idm45227213318336-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_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code>. <p> 2030 2031</p> 2032<p><b>Exception Safety. </b>No-throw. </p> 2033<p> 2034</p> 2035<p><b>Iterator Invalidation. </b>Does not invalidate any iterators. </p> 2036<p> 2037</p> 2038<p><b>Complexity. </b>Constant (in the size of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code>). </p> 2039<p> 2040</p> 2041<p><span class="bold"><strong>See Also:</strong></span></p> 2042<p><code class="computeroutput">reserve()</code>, <code class="computeroutput">size()</code>, <code class="computeroutput">max_size()</code>, <code class="computeroutput">set_capacity(capacity_type)</code> </p> 2043<p> 2044</p> 2045<p> 2046</p> 2047<div class="variablelist"><table border="0" class="variablelist compact"> 2048<colgroup> 2049<col align="left" valign="top"> 2050<col> 2051</colgroup> 2052<tbody> 2053<tr> 2054<td><p><span class="term">Returns:</span></p></td> 2055<td><p>The maximum number of elements which can be stored in the <code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code>. </p></td> 2056</tr> 2057<tr> 2058<td><p><span class="term">Throws:</span></p></td> 2059<td>Nothing. </td> 2060</tr> 2061</tbody> 2062</table></div> 2063</li> 2064<li class="listitem"> 2065<pre class="literallayout"><span class="keyword">void</span> <a name="idm45227213306576-bb"></a><span class="identifier">set_capacity</span><span class="special">(</span><span class="identifier">capacity_type</span> new_capacity<span class="special">)</span><span class="special">;</span></pre>Change the capacity of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code>. <p> 2066 2067 2068 2069</p> 2070<p><b>Exception Safety. </b>Strong. </p> 2071<p> 2072</p> 2073<p><b>Iterator Invalidation. </b>Invalidates all iterators pointing to the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code> (except iterators equal to <code class="computeroutput">end()</code>) if the new capacity is different from the original. </p> 2074<p> 2075</p> 2076<p><b>Complexity. </b>Linear (in <code class="computeroutput">min[size(), new_capacity]</code>). </p> 2077<p> 2078</p> 2079<p><span class="bold"><strong>See Also:</strong></span></p> 2080<p><code class="computeroutput">rset_capacity(capacity_type)</code>, <code class="computeroutput">resize(size_type, const_reference)</code> </p> 2081<p> 2082</p> 2083<p> 2084</p> 2085<div class="variablelist"><table border="0" class="variablelist compact"> 2086<colgroup> 2087<col align="left" valign="top"> 2088<col> 2089</colgroup> 2090<tbody> 2091<tr> 2092<td><p><span class="term">Parameters:</span></p></td> 2093<td><div class="variablelist"><table border="0" class="variablelist compact"> 2094<colgroup> 2095<col align="left" valign="top"> 2096<col> 2097</colgroup> 2098<tbody><tr> 2099<td><p><span class="term"><code class="computeroutput">new_capacity</code></span></p></td> 2100<td><p>The new capacity. </p></td> 2101</tr></tbody> 2102</table></div></td> 2103</tr> 2104<tr> 2105<td><p><span class="term">Requires:</span></p></td> 2106<td><p>If <code class="computeroutput">T</code> is a move only type, then compiler shall support <code class="computeroutput">noexcept</code> modifiers and move constructor of <code class="computeroutput">T</code> must be marked with it (must not throw exceptions). </p></td> 2107</tr> 2108<tr> 2109<td><p><span class="term">Postconditions:</span></p></td> 2110<td><p><code class="computeroutput">capacity() == new_capacity && size() <= new_capacity</code><br> 2111<br> 2112 If the current number of elements stored in the <code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code> is greater than the desired new capacity then number of <code class="computeroutput">[size() - new_capacity]</code> <span class="bold"><strong>last</strong></span> elements will be removed and the new size will be equal to <code class="computeroutput">new_capacity</code>. </p></td> 2113</tr> 2114<tr> 2115<td><p><span class="term">Throws:</span></p></td> 2116<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> 2117</tr> 2118</tbody> 2119</table></div> 2120</li> 2121<li class="listitem"> 2122<pre class="literallayout"><span class="keyword">void</span> <a name="idm45227213288080-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_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code>. <p> 2123 2124 2125</p> 2126<p><b>Exception Safety. </b>Basic. </p> 2127<p> 2128</p> 2129<p><b>Iterator Invalidation. </b>Invalidates all iterators pointing to the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code> (except iterators equal to <code class="computeroutput">end()</code>) if the new size is greater than the current capacity. Invalidates iterators pointing to the removed elements if the new size is lower that the original size. Otherwise it does not invalidate any iterator. </p> 2130<p> 2131</p> 2132<p><b>Complexity. </b>Linear (in the new size of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code>). </p> 2133<p> 2134</p> 2135<p><span class="bold"><strong>See Also:</strong></span></p> 2136<p><code class="computeroutput">rresize(size_type, const_reference)</code>, <code class="computeroutput">set_capacity(capacity_type)</code> </p> 2137<p> 2138</p> 2139<p> 2140</p> 2141<div class="variablelist"><table border="0" class="variablelist compact"> 2142<colgroup> 2143<col align="left" valign="top"> 2144<col> 2145</colgroup> 2146<tbody> 2147<tr> 2148<td><p><span class="term">Parameters:</span></p></td> 2149<td><div class="variablelist"><table border="0" class="variablelist compact"> 2150<colgroup> 2151<col align="left" valign="top"> 2152<col> 2153</colgroup> 2154<tbody> 2155<tr> 2156<td><p><span class="term"><code class="computeroutput">item</code></span></p></td> 2157<td><p>The element the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</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> 2158</tr> 2159<tr> 2160<td><p><span class="term"><code class="computeroutput">new_size</code></span></p></td> 2161<td><p>The new size. </p></td> 2162</tr> 2163</tbody> 2164</table></div></td> 2165</tr> 2166<tr> 2167<td><p><span class="term">Postconditions:</span></p></td> 2168<td><p><code class="computeroutput">size() == new_size && capacity() >= new_size</code><br> 2169<br> 2170 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_buffer.html" title="Class template circular_buffer">circular_buffer</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> 2171 If the current number of elements stored in the <code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</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.) </p></td> 2172</tr> 2173<tr> 2174<td><p><span class="term">Throws:</span></p></td> 2175<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> 2176</tr> 2177</tbody> 2178</table></div> 2179</li> 2180<li class="listitem"> 2181<pre class="literallayout"><span class="keyword">void</span> <a name="idm45227213265840-bb"></a><span class="identifier">rset_capacity</span><span class="special">(</span><span class="identifier">capacity_type</span> new_capacity<span class="special">)</span><span class="special">;</span></pre>Change the capacity of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code>. <p> 2182 2183 2184 2185</p> 2186<p><b>Exception Safety. </b>Strong. </p> 2187<p> 2188</p> 2189<p><b>Iterator Invalidation. </b>Invalidates all iterators pointing to the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code> (except iterators equal to <code class="computeroutput">end()</code>) if the new capacity is different from the original. </p> 2190<p> 2191</p> 2192<p><b>Complexity. </b>Linear (in <code class="computeroutput">min[size(), new_capacity]</code>). </p> 2193<p> 2194</p> 2195<p><span class="bold"><strong>See Also:</strong></span></p> 2196<p><code class="computeroutput">set_capacity(capacity_type)</code>, <code class="computeroutput">rresize(size_type, const_reference)</code> </p> 2197<p> 2198</p> 2199<p> 2200</p> 2201<div class="variablelist"><table border="0" class="variablelist compact"> 2202<colgroup> 2203<col align="left" valign="top"> 2204<col> 2205</colgroup> 2206<tbody> 2207<tr> 2208<td><p><span class="term">Parameters:</span></p></td> 2209<td><div class="variablelist"><table border="0" class="variablelist compact"> 2210<colgroup> 2211<col align="left" valign="top"> 2212<col> 2213</colgroup> 2214<tbody><tr> 2215<td><p><span class="term"><code class="computeroutput">new_capacity</code></span></p></td> 2216<td><p>The new capacity. </p></td> 2217</tr></tbody> 2218</table></div></td> 2219</tr> 2220<tr> 2221<td><p><span class="term">Requires:</span></p></td> 2222<td><p>If <code class="computeroutput">T</code> is a move only type, then compiler shall support <code class="computeroutput">noexcept</code> modifiers and move constructor of <code class="computeroutput">T</code> must be marked with it (must not throw exceptions). </p></td> 2223</tr> 2224<tr> 2225<td><p><span class="term">Postconditions:</span></p></td> 2226<td><p><code class="computeroutput">capacity() == new_capacity && size() <= new_capacity</code><br> 2227<br> 2228 If the current number of elements stored in the <code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code> is greater than the desired new capacity then number of <code class="computeroutput">[size() - new_capacity]</code> <span class="bold"><strong>first</strong></span> elements will be removed and the new size will be equal to <code class="computeroutput">new_capacity</code>. </p></td> 2229</tr> 2230<tr> 2231<td><p><span class="term">Throws:</span></p></td> 2232<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> 2233</tr> 2234</tbody> 2235</table></div> 2236</li> 2237<li class="listitem"> 2238<pre class="literallayout"><span class="keyword">void</span> <a name="idm45227213247344-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_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code>. <p> 2239 2240 2241</p> 2242<p><b>Exception Safety. </b>Basic. </p> 2243<p> 2244</p> 2245<p><b>Iterator Invalidation. </b>Invalidates all iterators pointing to the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code> (except iterators equal to <code class="computeroutput">end()</code>) if the new size is greater than the current capacity. Invalidates iterators pointing to the removed elements if the new size is lower that the original size. Otherwise it does not invalidate any iterator. </p> 2246<p> 2247</p> 2248<p><b>Complexity. </b>Linear (in the new size of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code>). </p> 2249<p> 2250</p> 2251<p><span class="bold"><strong>See Also:</strong></span></p> 2252<p><code class="computeroutput">resize(size_type, const_reference)</code>, <code class="computeroutput">rset_capacity(capacity_type)</code> </p> 2253<p> 2254</p> 2255<p> 2256</p> 2257<div class="variablelist"><table border="0" class="variablelist compact"> 2258<colgroup> 2259<col align="left" valign="top"> 2260<col> 2261</colgroup> 2262<tbody> 2263<tr> 2264<td><p><span class="term">Parameters:</span></p></td> 2265<td><div class="variablelist"><table border="0" class="variablelist compact"> 2266<colgroup> 2267<col align="left" valign="top"> 2268<col> 2269</colgroup> 2270<tbody> 2271<tr> 2272<td><p><span class="term"><code class="computeroutput">item</code></span></p></td> 2273<td><p>The element the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</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> 2274</tr> 2275<tr> 2276<td><p><span class="term"><code class="computeroutput">new_size</code></span></p></td> 2277<td><p>The new size. </p></td> 2278</tr> 2279</tbody> 2280</table></div></td> 2281</tr> 2282<tr> 2283<td><p><span class="term">Postconditions:</span></p></td> 2284<td><p><code class="computeroutput">size() == new_size && capacity() >= new_size</code><br> 2285<br> 2286 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_buffer.html" title="Class template circular_buffer">circular_buffer</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> 2287 If the current number of elements stored in the <code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</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.) </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(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="idm45227213225104-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 <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code>. <p>The content of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code> will be removed and replaced with <code class="computeroutput">n</code> copies of the <code class="computeroutput">item</code>. 2298 2299 2300</p> 2301<p><b>Exception Safety. </b>Basic. </p> 2302<p> 2303</p> 2304<p><b>Iterator Invalidation. </b>Invalidates all iterators pointing to the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code> (except iterators equal to <code class="computeroutput">end()</code>). </p> 2305<p> 2306</p> 2307<p><b>Complexity. </b>Linear (in the <code class="computeroutput">n</code>). </p> 2308<p> 2309</p> 2310<p><span class="bold"><strong>See Also:</strong></span></p> 2311<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> 2312<p> 2313</p> 2314<p> 2315</p> 2316<div class="variablelist"><table border="0" class="variablelist compact"> 2317<colgroup> 2318<col align="left" valign="top"> 2319<col> 2320</colgroup> 2321<tbody> 2322<tr> 2323<td><p><span class="term">Parameters:</span></p></td> 2324<td><div class="variablelist"><table border="0" class="variablelist compact"> 2325<colgroup> 2326<col align="left" valign="top"> 2327<col> 2328</colgroup> 2329<tbody> 2330<tr> 2331<td><p><span class="term"><code class="computeroutput">item</code></span></p></td> 2332<td><p>The element the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code> will be filled with. </p></td> 2333</tr> 2334<tr> 2335<td><p><span class="term"><code class="computeroutput">n</code></span></p></td> 2336<td><p>The number of elements the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code> will be filled with. </p></td> 2337</tr> 2338</tbody> 2339</table></div></td> 2340</tr> 2341<tr> 2342<td><p><span class="term">Postconditions:</span></p></td> 2343<td><p><code class="computeroutput">capacity() == n && size() == n && (*this)[0] == item && (*this)[1] == item && ... && (*this) [n - 1] == item</code> </p></td> 2344</tr> 2345<tr> 2346<td><p><span class="term">Throws:</span></p></td> 2347<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> 2348</tr> 2349</tbody> 2350</table></div> 2351</li> 2352<li class="listitem"> 2353<pre class="literallayout"><span class="keyword">void</span> <a name="idm45227213206096-bb"></a><span class="identifier">assign</span><span class="special">(</span><span class="identifier">capacity_type</span> buffer_capacity<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 <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code> specifying the capacity. <p>The capacity of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</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_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code> will be removed and replaced with <code class="computeroutput">n</code> copies of the <code class="computeroutput">item</code>. 2354 2355 2356 2357</p> 2358<p><b>Exception Safety. </b>Basic. </p> 2359<p> 2360</p> 2361<p><b>Iterator Invalidation. </b>Invalidates all iterators pointing to the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code> (except iterators equal to <code class="computeroutput">end()</code>). </p> 2362<p> 2363</p> 2364<p><b>Complexity. </b>Linear (in the <code class="computeroutput">n</code>). </p> 2365<p> 2366</p> 2367<p><span class="bold"><strong>See Also:</strong></span></p> 2368<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> 2369<p> 2370</p> 2371<p> 2372</p> 2373<div class="variablelist"><table border="0" class="variablelist compact"> 2374<colgroup> 2375<col align="left" valign="top"> 2376<col> 2377</colgroup> 2378<tbody> 2379<tr> 2380<td><p><span class="term">Parameters:</span></p></td> 2381<td><div class="variablelist"><table border="0" class="variablelist compact"> 2382<colgroup> 2383<col align="left" valign="top"> 2384<col> 2385</colgroup> 2386<tbody> 2387<tr> 2388<td><p><span class="term"><code class="computeroutput">buffer_capacity</code></span></p></td> 2389<td><p>The new capacity. </p></td> 2390</tr> 2391<tr> 2392<td><p><span class="term"><code class="computeroutput">item</code></span></p></td> 2393<td><p>The element the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code> will be filled with. </p></td> 2394</tr> 2395<tr> 2396<td><p><span class="term"><code class="computeroutput">n</code></span></p></td> 2397<td><p>The number of elements the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code> will be filled with. </p></td> 2398</tr> 2399</tbody> 2400</table></div></td> 2401</tr> 2402<tr> 2403<td><p><span class="term">Requires:</span></p></td> 2404<td><p><code class="computeroutput">capacity >= n</code> </p></td> 2405</tr> 2406<tr> 2407<td><p><span class="term">Postconditions:</span></p></td> 2408<td><p><code class="computeroutput">capacity() == buffer_capacity && size() == n && (*this)[0] == item && (*this)[1] == item && ... && (*this) [n - 1] == item </code> </p></td> 2409</tr> 2410<tr> 2411<td><p><span class="term">Throws:</span></p></td> 2412<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> 2413</tr> 2414</tbody> 2415</table></div> 2416</li> 2417<li class="listitem"> 2418<pre class="literallayout"><span class="keyword">template</span><span class="special"><</span><span class="keyword">typename</span> InputIterator<span class="special">></span> 2419 <span class="keyword">void</span> <a name="idm45227213184208-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 <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code>. <p>The content of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code> will be removed and replaced with copies of elements from the specified range. 2420 2421 2422 2423</p> 2424<p><b>Exception Safety. </b>Basic. </p> 2425<p> 2426</p> 2427<p><b>Iterator Invalidation. </b>Invalidates all iterators pointing to the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code> (except iterators equal to <code class="computeroutput">end()</code>). </p> 2428<p> 2429</p> 2430<p><b>Complexity. </b>Linear (in the <code class="computeroutput">std::distance(first, last)</code>). </p> 2431<p> 2432</p> 2433<p><span class="bold"><strong>See Also:</strong></span></p> 2434<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> 2435<p> 2436</p> 2437<p> 2438</p> 2439<div class="variablelist"><table border="0" class="variablelist compact"> 2440<colgroup> 2441<col align="left" valign="top"> 2442<col> 2443</colgroup> 2444<tbody> 2445<tr> 2446<td><p><span class="term">Parameters:</span></p></td> 2447<td><div class="variablelist"><table border="0" class="variablelist compact"> 2448<colgroup> 2449<col align="left" valign="top"> 2450<col> 2451</colgroup> 2452<tbody> 2453<tr> 2454<td><p><span class="term"><code class="computeroutput">first</code></span></p></td> 2455<td><p>The beginning of the range to be copied. </p></td> 2456</tr> 2457<tr> 2458<td><p><span class="term"><code class="computeroutput">last</code></span></p></td> 2459<td><p>The end of the range to be copied. </p></td> 2460</tr> 2461</tbody> 2462</table></div></td> 2463</tr> 2464<tr> 2465<td><p><span class="term">Requires:</span></p></td> 2466<td><p>Valid range <code class="computeroutput">[first, last)</code>.<br> 2467 <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> 2468</tr> 2469<tr> 2470<td><p><span class="term">Postconditions:</span></p></td> 2471<td><p><code class="computeroutput">capacity() == std::distance(first, last) && size() == std::distance(first, last) && (*this)[0]== *first && (*this)[1] == *(first + 1) && ... && (*this)[std::distance(first, last) - 1] == *(last - 1)</code> </p></td> 2472</tr> 2473<tr> 2474<td><p><span class="term">Throws:</span></p></td> 2475<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> 2476</tr> 2477</tbody> 2478</table></div> 2479</li> 2480<li class="listitem"> 2481<pre class="literallayout"><span class="keyword">template</span><span class="special"><</span><span class="keyword">typename</span> InputIterator<span class="special">></span> 2482 <span class="keyword">void</span> <a name="idm45227213164224-bb"></a><span class="identifier">assign</span><span class="special">(</span><span class="identifier">capacity_type</span> buffer_capacity<span class="special">,</span> <span class="identifier">InputIterator</span> first<span class="special">,</span> 2483 <span class="identifier">InputIterator</span> last<span class="special">)</span><span class="special">;</span></pre>Assign a copy of the range into the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code> specifying the capacity. <p>The capacity of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</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_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code> will be removed and replaced with copies of elements from the specified range. 2484 2485 2486 2487</p> 2488<p><b>Exception Safety. </b>Basic. </p> 2489<p> 2490</p> 2491<p><b>Iterator Invalidation. </b>Invalidates all iterators pointing to the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code> (except iterators equal to <code class="computeroutput">end()</code>). </p> 2492<p> 2493</p> 2494<p><b>Complexity. </b>Linear (in <code class="computeroutput">std::distance(first, last)</code>; in <code class="computeroutput">min[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> 2495<p> 2496</p> 2497<p><span class="bold"><strong>See Also:</strong></span></p> 2498<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> 2499<p> 2500</p> 2501<p> 2502</p> 2503<div class="variablelist"><table border="0" class="variablelist compact"> 2504<colgroup> 2505<col align="left" valign="top"> 2506<col> 2507</colgroup> 2508<tbody> 2509<tr> 2510<td><p><span class="term">Parameters:</span></p></td> 2511<td><div class="variablelist"><table border="0" class="variablelist compact"> 2512<colgroup> 2513<col align="left" valign="top"> 2514<col> 2515</colgroup> 2516<tbody> 2517<tr> 2518<td><p><span class="term"><code class="computeroutput">buffer_capacity</code></span></p></td> 2519<td><p>The new capacity. </p></td> 2520</tr> 2521<tr> 2522<td><p><span class="term"><code class="computeroutput">first</code></span></p></td> 2523<td><p>The beginning of the range to be copied. </p></td> 2524</tr> 2525<tr> 2526<td><p><span class="term"><code class="computeroutput">last</code></span></p></td> 2527<td><p>The end of the range to be copied. </p></td> 2528</tr> 2529</tbody> 2530</table></div></td> 2531</tr> 2532<tr> 2533<td><p><span class="term">Requires:</span></p></td> 2534<td><p>Valid range <code class="computeroutput">[first, last)</code>.<br> 2535 <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> 2536</tr> 2537<tr> 2538<td><p><span class="term">Postconditions:</span></p></td> 2539<td><p><code class="computeroutput">capacity() == buffer_capacity && size() <= std::distance(first, last) && (*this)[0]== *(last - buffer_capacity) && (*this)[1] == *(last - buffer_capacity + 1) && ... && (*this)[buffer_capacity - 1] == *(last - 1)</code><br> 2540<br> 2541 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">buffer_capacity</code> then only elements from the range <code class="computeroutput">[last - buffer_capacity, last)</code> will be copied. </p></td> 2542</tr> 2543<tr> 2544<td><p><span class="term">Throws:</span></p></td> 2545<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> 2546</tr> 2547</tbody> 2548</table></div> 2549</li> 2550<li class="listitem"> 2551<pre class="literallayout"><span class="keyword">void</span> <a name="idm45227213138704-bb"></a><span class="identifier">swap</span><span class="special">(</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> cb<span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span></pre>Swap the contents of two <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code>s. <p> 2552 2553 2554</p> 2555<p><b>Exception Safety. </b>No-throw. </p> 2556<p> 2557</p> 2558<p><b>Iterator Invalidation. </b>Invalidates all iterators of both <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code>s. (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 <a href="../#debug" target="_top">Debug Support</a> off otherwise an assertion will report an error if such invalidated iterator is used.) </p> 2559<p> 2560</p> 2561<p><b>Complexity. </b>Constant (in the size of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code>). </p> 2562<p> 2563</p> 2564<p><span class="bold"><strong>See Also:</strong></span></p> 2565<p><code class="computeroutput">swap(circular_buffer<T, Alloc>&, circular_buffer<T, Alloc>&)</code> </p> 2566<p> 2567</p> 2568<p> 2569</p> 2570<div class="variablelist"><table border="0" class="variablelist compact"> 2571<colgroup> 2572<col align="left" valign="top"> 2573<col> 2574</colgroup> 2575<tbody> 2576<tr> 2577<td><p><span class="term">Parameters:</span></p></td> 2578<td><div class="variablelist"><table border="0" class="variablelist compact"> 2579<colgroup> 2580<col align="left" valign="top"> 2581<col> 2582</colgroup> 2583<tbody><tr> 2584<td><p><span class="term"><code class="computeroutput">cb</code></span></p></td> 2585<td><p>The <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code> whose content will be swapped. </p></td> 2586</tr></tbody> 2587</table></div></td> 2588</tr> 2589<tr> 2590<td><p><span class="term">Postconditions:</span></p></td> 2591<td><p><code class="computeroutput">this</code> contains elements of <code class="computeroutput">cb</code> and vice versa; the capacity of <code class="computeroutput">this</code> equals to the capacity of <code class="computeroutput">cb</code> and vice versa. </p></td> 2592</tr> 2593<tr> 2594<td><p><span class="term">Throws:</span></p></td> 2595<td>Nothing. </td> 2596</tr> 2597</tbody> 2598</table></div> 2599</li> 2600<li class="listitem"> 2601<pre class="literallayout"><span class="keyword">void</span> <a name="idm45227213123440-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 <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code>. <p> 2602 2603 2604</p> 2605<p><b>Exception Safety. </b>Basic; no-throw if the operation in the <span class="emphasis"><em>Throws</em></span> section does not throw anything. </p> 2606<p> 2607</p> 2608<p><b>Iterator Invalidation. </b>Does not invalidate any iterators with the exception of iterators pointing to the overwritten element. </p> 2609<p> 2610</p> 2611<p><b>Complexity. </b>Constant (in the size of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code>). </p> 2612<p> 2613</p> 2614<p><span class="bold"><strong>See Also:</strong></span></p> 2615<p><code class="computeroutput">push_front(const_reference)</code>, <code class="computeroutput">pop_back()</code>, <code class="computeroutput">pop_front()</code> </p> 2616<p> 2617</p> 2618<p> 2619</p> 2620<div class="variablelist"><table border="0" class="variablelist compact"> 2621<colgroup> 2622<col align="left" valign="top"> 2623<col> 2624</colgroup> 2625<tbody> 2626<tr> 2627<td><p><span class="term">Parameters:</span></p></td> 2628<td><div class="variablelist"><table border="0" class="variablelist compact"> 2629<colgroup> 2630<col align="left" valign="top"> 2631<col> 2632</colgroup> 2633<tbody><tr> 2634<td><p><span class="term"><code class="computeroutput">item</code></span></p></td> 2635<td><p>The element to be inserted. </p></td> 2636</tr></tbody> 2637</table></div></td> 2638</tr> 2639<tr> 2640<td><p><span class="term">Postconditions:</span></p></td> 2641<td><p>if <code class="computeroutput">capacity() > 0</code> then <code class="computeroutput">back() == item</code><br> 2642 If the <code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code> is full, the first element will be removed. If the capacity is <code class="computeroutput">0</code>, nothing will be inserted. </p></td> 2643</tr> 2644<tr> 2645<td><p><span class="term">Throws:</span></p></td> 2646<td>Whatever <code class="computeroutput">T::T(const T&)</code> throws. Whatever <code class="computeroutput">T::operator = (const T&)</code> throws. </td> 2647</tr> 2648</tbody> 2649</table></div> 2650</li> 2651<li class="listitem"> 2652<pre class="literallayout"><span class="keyword">void</span> <a name="idm45227213108320-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 <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code> using rvalue references or rvalues references emulation. <p> 2653 2654 2655</p> 2656<p><b>Exception Safety. </b>Basic; no-throw if the operation in the <span class="emphasis"><em>Throws</em></span> section does not throw anything. </p> 2657<p> 2658</p> 2659<p><b>Iterator Invalidation. </b>Does not invalidate any iterators with the exception of iterators pointing to the overwritten element. </p> 2660<p> 2661</p> 2662<p><b>Complexity. </b>Constant (in the size of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code>). </p> 2663<p> 2664</p> 2665<p><span class="bold"><strong>See Also:</strong></span></p> 2666<p><code class="computeroutput">push_front(const_reference)</code>, <code class="computeroutput">pop_back()</code>, <code class="computeroutput">pop_front()</code> </p> 2667<p> 2668</p> 2669<p> 2670</p> 2671<div class="variablelist"><table border="0" class="variablelist compact"> 2672<colgroup> 2673<col align="left" valign="top"> 2674<col> 2675</colgroup> 2676<tbody> 2677<tr> 2678<td><p><span class="term">Parameters:</span></p></td> 2679<td><div class="variablelist"><table border="0" class="variablelist compact"> 2680<colgroup> 2681<col align="left" valign="top"> 2682<col> 2683</colgroup> 2684<tbody><tr> 2685<td><p><span class="term"><code class="computeroutput">item</code></span></p></td> 2686<td><p>The element to be inserted. </p></td> 2687</tr></tbody> 2688</table></div></td> 2689</tr> 2690<tr> 2691<td><p><span class="term">Postconditions:</span></p></td> 2692<td><p>if <code class="computeroutput">capacity() > 0</code> then <code class="computeroutput">back() == item</code><br> 2693 If the <code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code> is full, the first element will be removed. If the capacity is <code class="computeroutput">0</code>, nothing will be inserted. </p></td> 2694</tr> 2695<tr> 2696<td><p><span class="term">Throws:</span></p></td> 2697<td>Whatever <code class="computeroutput">T::T(T&&)</code> throws. Whatever <code class="computeroutput">T::operator = (T&&)</code> throws. </td> 2698</tr> 2699</tbody> 2700</table></div> 2701</li> 2702<li class="listitem"> 2703<pre class="literallayout"><span class="keyword">void</span> <a name="idm45227213093168-bb"></a><span class="identifier">push_back</span><span class="special">(</span><span class="special">)</span><span class="special">;</span></pre>Insert a new default-constructed element at the end of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code>. <p> 2704 2705</p> 2706<p><b>Exception Safety. </b>Basic; no-throw if the operation in the <span class="emphasis"><em>Throws</em></span> section does not throw anything. </p> 2707<p> 2708</p> 2709<p><b>Iterator Invalidation. </b>Does not invalidate any iterators with the exception of iterators pointing to the overwritten element. </p> 2710<p> 2711</p> 2712<p><b>Complexity. </b>Constant (in the size of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code>). </p> 2713<p> 2714</p> 2715<p><span class="bold"><strong>See Also:</strong></span></p> 2716<p><code class="computeroutput">push_front(const_reference)</code>, <code class="computeroutput">pop_back()</code>, <code class="computeroutput">pop_front()</code> </p> 2717<p> 2718</p> 2719<p> 2720</p> 2721<div class="variablelist"><table border="0" class="variablelist compact"> 2722<colgroup> 2723<col align="left" valign="top"> 2724<col> 2725</colgroup> 2726<tbody> 2727<tr> 2728<td><p><span class="term">Postconditions:</span></p></td> 2729<td><p>if <code class="computeroutput">capacity() > 0</code> then <code class="computeroutput">back() == item</code><br> 2730 If the <code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code> is full, the first element will be removed. If the capacity is <code class="computeroutput">0</code>, nothing will be inserted. </p></td> 2731</tr> 2732<tr> 2733<td><p><span class="term">Throws:</span></p></td> 2734<td>Whatever <code class="computeroutput">T::T()</code> throws. Whatever <code class="computeroutput">T::T(T&&)</code> throws. Whatever <code class="computeroutput">T::operator = (T&&)</code> throws. </td> 2735</tr> 2736</tbody> 2737</table></div> 2738</li> 2739<li class="listitem"> 2740<pre class="literallayout"><span class="keyword">void</span> <a name="idm45227213078704-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 <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code>. <p> 2741 2742 2743</p> 2744<p><b>Exception Safety. </b>Basic; no-throw if the operation in the <span class="emphasis"><em>Throws</em></span> section does not throw anything. </p> 2745<p> 2746</p> 2747<p><b>Iterator Invalidation. </b>Does not invalidate any iterators with the exception of iterators pointing to the overwritten element. </p> 2748<p> 2749</p> 2750<p><b>Complexity. </b>Constant (in the size of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code>). </p> 2751<p> 2752</p> 2753<p><span class="bold"><strong>See Also:</strong></span></p> 2754<p><code class="computeroutput">push_back(const_reference)</code>, <code class="computeroutput">pop_back()</code>, <code class="computeroutput">pop_front()</code> </p> 2755<p> 2756</p> 2757<p> 2758</p> 2759<div class="variablelist"><table border="0" class="variablelist compact"> 2760<colgroup> 2761<col align="left" valign="top"> 2762<col> 2763</colgroup> 2764<tbody> 2765<tr> 2766<td><p><span class="term">Parameters:</span></p></td> 2767<td><div class="variablelist"><table border="0" class="variablelist compact"> 2768<colgroup> 2769<col align="left" valign="top"> 2770<col> 2771</colgroup> 2772<tbody><tr> 2773<td><p><span class="term"><code class="computeroutput">item</code></span></p></td> 2774<td><p>The element to be inserted. </p></td> 2775</tr></tbody> 2776</table></div></td> 2777</tr> 2778<tr> 2779<td><p><span class="term">Postconditions:</span></p></td> 2780<td><p>if <code class="computeroutput">capacity() > 0</code> then <code class="computeroutput">front() == item</code><br> 2781 If the <code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code> is full, the last element will be removed. If the capacity is <code class="computeroutput">0</code>, nothing will be inserted. </p></td> 2782</tr> 2783<tr> 2784<td><p><span class="term">Throws:</span></p></td> 2785<td>Whatever <code class="computeroutput">T::T(const T&)</code> throws. Whatever <code class="computeroutput">T::operator = (const T&)</code> throws. </td> 2786</tr> 2787</tbody> 2788</table></div> 2789</li> 2790<li class="listitem"> 2791<pre class="literallayout"><span class="keyword">void</span> <a name="idm45227213063568-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 <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code> using rvalue references or rvalues references emulation. <p> 2792 2793 2794</p> 2795<p><b>Exception Safety. </b>Basic; no-throw if the operation in the <span class="emphasis"><em>Throws</em></span> section does not throw anything. </p> 2796<p> 2797</p> 2798<p><b>Iterator Invalidation. </b>Does not invalidate any iterators with the exception of iterators pointing to the overwritten element. </p> 2799<p> 2800</p> 2801<p><b>Complexity. </b>Constant (in the size of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code>). </p> 2802<p> 2803</p> 2804<p><span class="bold"><strong>See Also:</strong></span></p> 2805<p><code class="computeroutput">push_back(const_reference)</code>, <code class="computeroutput">pop_back()</code>, <code class="computeroutput">pop_front()</code> </p> 2806<p> 2807</p> 2808<p> 2809</p> 2810<div class="variablelist"><table border="0" class="variablelist compact"> 2811<colgroup> 2812<col align="left" valign="top"> 2813<col> 2814</colgroup> 2815<tbody> 2816<tr> 2817<td><p><span class="term">Parameters:</span></p></td> 2818<td><div class="variablelist"><table border="0" class="variablelist compact"> 2819<colgroup> 2820<col align="left" valign="top"> 2821<col> 2822</colgroup> 2823<tbody><tr> 2824<td><p><span class="term"><code class="computeroutput">item</code></span></p></td> 2825<td><p>The element to be inserted. </p></td> 2826</tr></tbody> 2827</table></div></td> 2828</tr> 2829<tr> 2830<td><p><span class="term">Postconditions:</span></p></td> 2831<td><p>if <code class="computeroutput">capacity() > 0</code> then <code class="computeroutput">front() == item</code><br> 2832 If the <code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code> is full, the last element will be removed. If the capacity is <code class="computeroutput">0</code>, nothing will be inserted. </p></td> 2833</tr> 2834<tr> 2835<td><p><span class="term">Throws:</span></p></td> 2836<td>Whatever <code class="computeroutput">T::T(T&&)</code> throws. Whatever <code class="computeroutput">T::operator = (T&&)</code> throws. </td> 2837</tr> 2838</tbody> 2839</table></div> 2840</li> 2841<li class="listitem"> 2842<pre class="literallayout"><span class="keyword">void</span> <a name="idm45227213048400-bb"></a><span class="identifier">push_front</span><span class="special">(</span><span class="special">)</span><span class="special">;</span></pre>Insert a new default-constructed element at the beginning of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code>. <p> 2843 2844</p> 2845<p><b>Exception Safety. </b>Basic; no-throw if the operation in the <span class="emphasis"><em>Throws</em></span> section does not throw anything. </p> 2846<p> 2847</p> 2848<p><b>Iterator Invalidation. </b>Does not invalidate any iterators with the exception of iterators pointing to the overwritten element. </p> 2849<p> 2850</p> 2851<p><b>Complexity. </b>Constant (in the size of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code>). </p> 2852<p> 2853</p> 2854<p><span class="bold"><strong>See Also:</strong></span></p> 2855<p><code class="computeroutput">push_back(const_reference)</code>, <code class="computeroutput">pop_back()</code>, <code class="computeroutput">pop_front()</code> </p> 2856<p> 2857</p> 2858<p> 2859</p> 2860<div class="variablelist"><table border="0" class="variablelist compact"> 2861<colgroup> 2862<col align="left" valign="top"> 2863<col> 2864</colgroup> 2865<tbody> 2866<tr> 2867<td><p><span class="term">Postconditions:</span></p></td> 2868<td><p>if <code class="computeroutput">capacity() > 0</code> then <code class="computeroutput">front() == item</code><br> 2869 If the <code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code> is full, the last element will be removed. If the capacity is <code class="computeroutput">0</code>, nothing will be inserted. </p></td> 2870</tr> 2871<tr> 2872<td><p><span class="term">Throws:</span></p></td> 2873<td>Whatever <code class="computeroutput">T::T()</code> throws. Whatever <code class="computeroutput">T::T(T&&)</code> throws. Whatever <code class="computeroutput">T::operator = (T&&)</code> throws. </td> 2874</tr> 2875</tbody> 2876</table></div> 2877</li> 2878<li class="listitem"> 2879<pre class="literallayout"><span class="keyword">void</span> <a name="idm45227213033936-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 <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code>. <p> 2880 2881 2882</p> 2883<p><b>Exception Safety. </b>No-throw. </p> 2884<p> 2885</p> 2886<p><b>Iterator Invalidation. </b>Invalidates only iterators pointing to the removed element. </p> 2887<p> 2888</p> 2889<p><b>Complexity. </b>Constant (in the size of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code>). </p> 2890<p> 2891</p> 2892<p><span class="bold"><strong>See Also:</strong></span></p> 2893<p><code class="computeroutput">pop_front()</code>, <code class="computeroutput">push_back(const_reference)</code>, <code class="computeroutput">push_front(const_reference)</code> </p> 2894<p> 2895</p> 2896<p> 2897</p> 2898<div class="variablelist"><table border="0" class="variablelist compact"> 2899<colgroup> 2900<col align="left" valign="top"> 2901<col> 2902</colgroup> 2903<tbody> 2904<tr> 2905<td><p><span class="term">Requires:</span></p></td> 2906<td><p><code class="computeroutput">!empty()</code> </p></td> 2907</tr> 2908<tr> 2909<td><p><span class="term">Postconditions:</span></p></td> 2910<td><p>The last element is removed from the <code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code>. </p></td> 2911</tr> 2912<tr> 2913<td><p><span class="term">Throws:</span></p></td> 2914<td>Nothing. </td> 2915</tr> 2916</tbody> 2917</table></div> 2918</li> 2919<li class="listitem"> 2920<pre class="literallayout"><span class="keyword">void</span> <a name="idm45227213022016-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 <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code>. <p> 2921 2922 2923</p> 2924<p><b>Exception Safety. </b>No-throw. </p> 2925<p> 2926</p> 2927<p><b>Iterator Invalidation. </b>Invalidates only iterators pointing to the removed element. </p> 2928<p> 2929</p> 2930<p><b>Complexity. </b>Constant (in the size of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code>). </p> 2931<p> 2932</p> 2933<p><span class="bold"><strong>See Also:</strong></span></p> 2934<p><code class="computeroutput">pop_back()</code>, <code class="computeroutput">push_back(const_reference)</code>, <code class="computeroutput">push_front(const_reference)</code> </p> 2935<p> 2936</p> 2937<p> 2938</p> 2939<div class="variablelist"><table border="0" class="variablelist compact"> 2940<colgroup> 2941<col align="left" valign="top"> 2942<col> 2943</colgroup> 2944<tbody> 2945<tr> 2946<td><p><span class="term">Requires:</span></p></td> 2947<td><p><code class="computeroutput">!empty()</code> </p></td> 2948</tr> 2949<tr> 2950<td><p><span class="term">Postconditions:</span></p></td> 2951<td><p>The first element is removed from the <code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code>. </p></td> 2952</tr> 2953<tr> 2954<td><p><span class="term">Throws:</span></p></td> 2955<td>Nothing. </td> 2956</tr> 2957</tbody> 2958</table></div> 2959</li> 2960<li class="listitem"> 2961<pre class="literallayout"><span class="identifier">iterator</span> <a name="idm45227213010096-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> 2962 2963 2964 2965 2966</p> 2967<p><b>Exception Safety. </b>Basic; no-throw if the operation in the <span class="emphasis"><em>Throws</em></span> section does not throw anything. </p> 2968<p> 2969</p> 2970<p><b>Iterator Invalidation. </b>Invalidates iterators pointing to the elements at the insertion point (including <code class="computeroutput">pos</code>) and iterators behind the insertion point (towards the end; except iterators equal to <code class="computeroutput">end()</code>). It also invalidates iterators pointing to the overwritten element. </p> 2971<p> 2972</p> 2973<p><b>Complexity. </b>Linear (in <code class="computeroutput">std::distance(pos, end())</code>). </p> 2974<p> 2975</p> 2976<p><span class="bold"><strong>See Also:</strong></span></p> 2977<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> 2978<p> 2979</p> 2980<p> 2981</p> 2982<div class="variablelist"><table border="0" class="variablelist compact"> 2983<colgroup> 2984<col align="left" valign="top"> 2985<col> 2986</colgroup> 2987<tbody> 2988<tr> 2989<td><p><span class="term">Parameters:</span></p></td> 2990<td><div class="variablelist"><table border="0" class="variablelist compact"> 2991<colgroup> 2992<col align="left" valign="top"> 2993<col> 2994</colgroup> 2995<tbody> 2996<tr> 2997<td><p><span class="term"><code class="computeroutput">item</code></span></p></td> 2998<td><p>The element to be inserted. </p></td> 2999</tr> 3000<tr> 3001<td><p><span class="term"><code class="computeroutput">pos</code></span></p></td> 3002<td><p>An iterator specifying the position where the <code class="computeroutput">item</code> will be inserted. </p></td> 3003</tr> 3004</tbody> 3005</table></div></td> 3006</tr> 3007<tr> 3008<td><p><span class="term">Requires:</span></p></td> 3009<td><p><code class="computeroutput">pos</code> is a valid iterator pointing to the <code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code> or its end. </p></td> 3010</tr> 3011<tr> 3012<td><p><span class="term">Postconditions:</span></p></td> 3013<td><p>The <code class="computeroutput">item</code> will be inserted at the position <code class="computeroutput">pos</code>.<br> 3014 If the <code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code> is full, the first element will be overwritten. If the <code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</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. </p></td> 3015</tr> 3016<tr> 3017<td><p><span class="term">Returns:</span></p></td> 3018<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> 3019</tr> 3020<tr> 3021<td><p><span class="term">Throws:</span></p></td> 3022<td>Whatever <code class="computeroutput">T::T(const T&)</code> throws. Whatever <code class="computeroutput">T::operator = (const T&)</code> throws. <a href="../circular_buffer/implementation.html#circular_buffer.implementation.exceptions_of_move_if_noexcept_t" target="_top">Exceptions of move_if_noexcept(T&)</a>.</td> 3023</tr> 3024</tbody> 3025</table></div> 3026</li> 3027<li class="listitem"> 3028<pre class="literallayout"><span class="identifier">iterator</span> <a name="idm45227212985728-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> 3029 3030 3031 3032 3033</p> 3034<p><b>Exception Safety. </b>Basic; no-throw if the operation in the <span class="emphasis"><em>Throws</em></span> section does not throw anything. </p> 3035<p> 3036</p> 3037<p><b>Iterator Invalidation. </b>Invalidates iterators pointing to the elements at the insertion point (including <code class="computeroutput">pos</code>) and iterators behind the insertion point (towards the end; except iterators equal to <code class="computeroutput">end()</code>). It also invalidates iterators pointing to the overwritten element. </p> 3038<p> 3039</p> 3040<p><b>Complexity. </b>Linear (in <code class="computeroutput">std::distance(pos, end())</code>). </p> 3041<p> 3042</p> 3043<p><span class="bold"><strong>See Also:</strong></span></p> 3044<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> 3045<p> 3046</p> 3047<p> 3048</p> 3049<div class="variablelist"><table border="0" class="variablelist compact"> 3050<colgroup> 3051<col align="left" valign="top"> 3052<col> 3053</colgroup> 3054<tbody> 3055<tr> 3056<td><p><span class="term">Parameters:</span></p></td> 3057<td><div class="variablelist"><table border="0" class="variablelist compact"> 3058<colgroup> 3059<col align="left" valign="top"> 3060<col> 3061</colgroup> 3062<tbody> 3063<tr> 3064<td><p><span class="term"><code class="computeroutput">item</code></span></p></td> 3065<td><p>The element to be inserted. </p></td> 3066</tr> 3067<tr> 3068<td><p><span class="term"><code class="computeroutput">pos</code></span></p></td> 3069<td><p>An iterator specifying the position where the <code class="computeroutput">item</code> will be inserted. </p></td> 3070</tr> 3071</tbody> 3072</table></div></td> 3073</tr> 3074<tr> 3075<td><p><span class="term">Requires:</span></p></td> 3076<td><p><code class="computeroutput">pos</code> is a valid iterator pointing to the <code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code> or its end. </p></td> 3077</tr> 3078<tr> 3079<td><p><span class="term">Postconditions:</span></p></td> 3080<td><p>The <code class="computeroutput">item</code> will be inserted at the position <code class="computeroutput">pos</code>.<br> 3081 If the <code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code> is full, the first element will be overwritten. If the <code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</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. </p></td> 3082</tr> 3083<tr> 3084<td><p><span class="term">Returns:</span></p></td> 3085<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> 3086</tr> 3087<tr> 3088<td><p><span class="term">Throws:</span></p></td> 3089<td>Whatever <code class="computeroutput">T::T(T&&)</code> throws. Whatever <code class="computeroutput">T::operator = (T&&)</code> throws. <a href="../circular_buffer/implementation.html#circular_buffer.implementation.exceptions_of_move_if_noexcept_t" target="_top">Exceptions of move_if_noexcept(T&)</a>. </td> 3090</tr> 3091</tbody> 3092</table></div> 3093</li> 3094<li class="listitem"> 3095<pre class="literallayout"><span class="identifier">iterator</span> <a name="idm45227212961376-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 a default-constructed element at the specified position. <p> 3096 3097 3098 3099 3100</p> 3101<p><b>Exception Safety. </b>Basic; no-throw if the operation in the <span class="emphasis"><em>Throws</em></span> section does not throw anything. </p> 3102<p> 3103</p> 3104<p><b>Iterator Invalidation. </b>Invalidates iterators pointing to the elements at the insertion point (including <code class="computeroutput">pos</code>) and iterators behind the insertion point (towards the end; except iterators equal to <code class="computeroutput">end()</code>). It also invalidates iterators pointing to the overwritten element. </p> 3105<p> 3106</p> 3107<p><b>Complexity. </b>Linear (in <code class="computeroutput">std::distance(pos, end())</code>). </p> 3108<p> 3109</p> 3110<p><span class="bold"><strong>See Also:</strong></span></p> 3111<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> 3112<p> 3113</p> 3114<p> 3115</p> 3116<div class="variablelist"><table border="0" class="variablelist compact"> 3117<colgroup> 3118<col align="left" valign="top"> 3119<col> 3120</colgroup> 3121<tbody> 3122<tr> 3123<td><p><span class="term">Parameters:</span></p></td> 3124<td><div class="variablelist"><table border="0" class="variablelist compact"> 3125<colgroup> 3126<col align="left" valign="top"> 3127<col> 3128</colgroup> 3129<tbody><tr> 3130<td><p><span class="term"><code class="computeroutput">pos</code></span></p></td> 3131<td><p>An iterator specifying the position where the <code class="computeroutput">item</code> will be inserted. </p></td> 3132</tr></tbody> 3133</table></div></td> 3134</tr> 3135<tr> 3136<td><p><span class="term">Requires:</span></p></td> 3137<td><p><code class="computeroutput">pos</code> is a valid iterator pointing to the <code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code> or its end. </p></td> 3138</tr> 3139<tr> 3140<td><p><span class="term">Postconditions:</span></p></td> 3141<td><p>The <code class="computeroutput">item</code> will be inserted at the position <code class="computeroutput">pos</code>.<br> 3142 If the <code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code> is full, the first element will be overwritten. If the <code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</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. </p></td> 3143</tr> 3144<tr> 3145<td><p><span class="term">Returns:</span></p></td> 3146<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> 3147</tr> 3148<tr> 3149<td><p><span class="term">Throws:</span></p></td> 3150<td>Whatever <code class="computeroutput">T::T()</code> throws. Whatever <code class="computeroutput">T::T(T&&)</code> throws. Whatever <code class="computeroutput">T::operator = (T&&)</code> throws. <a href="../circular_buffer/implementation.html#circular_buffer.implementation.exceptions_of_move_if_noexcept_t" target="_top">Exceptions of move_if_noexcept(T&)</a>. </td> 3151</tr> 3152</tbody> 3153</table></div> 3154</li> 3155<li class="listitem"> 3156<pre class="literallayout"><span class="keyword">void</span> <a name="idm45227212937680-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> 3157 3158 3159 3160</p> 3161<p><b>Exception Safety. </b>Basic; no-throw if the operations in the <span class="emphasis"><em>Throws</em></span> section do not throw anything. </p> 3162<p> 3163</p> 3164<p><b>Iterator Invalidation. </b>Invalidates iterators pointing to the elements at the insertion point (including <code class="computeroutput">pos</code>) and iterators behind the insertion point (towards the end; except iterators equal to <code class="computeroutput">end()</code>). It also invalidates iterators pointing to the overwritten elements. </p> 3165<p> 3166</p> 3167<p><b>Complexity. </b>Linear (in <code class="computeroutput">min[capacity(), std::distance(pos, end()) + n]</code>). </p> 3168<p> 3169</p> 3170<p><b>Example. </b>Consider a <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code> with the capacity of 6 and the size of 4. Its internal buffer may look like the one below.<br> 3171<br> 3172 <code class="computeroutput">|1|2|3|4| | |</code><br> 3173 <code class="computeroutput">p ___^</code><br> 3174<br> 3175After inserting 5 elements at the position <code class="computeroutput">p</code>:<br> 3176<br> 3177 <code class="computeroutput">insert(p, (size_t)5, 0);</code><br> 3178<br> 3179actually 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> 3180<br> 3181<code class="computeroutput">|0|0|0|0|3|4|</code><br> 3182 <br> 3183For 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> 3184<p> 3185</p> 3186<p><span class="bold"><strong>See Also:</strong></span></p> 3187<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> 3188<p> 3189</p> 3190<p> 3191</p> 3192<div class="variablelist"><table border="0" class="variablelist compact"> 3193<colgroup> 3194<col align="left" valign="top"> 3195<col> 3196</colgroup> 3197<tbody> 3198<tr> 3199<td><p><span class="term">Parameters:</span></p></td> 3200<td><div class="variablelist"><table border="0" class="variablelist compact"> 3201<colgroup> 3202<col align="left" valign="top"> 3203<col> 3204</colgroup> 3205<tbody> 3206<tr> 3207<td><p><span class="term"><code class="computeroutput">item</code></span></p></td> 3208<td><p>The element whose copies will be inserted. </p></td> 3209</tr> 3210<tr> 3211<td><p><span class="term"><code class="computeroutput">n</code></span></p></td> 3212<td><p>The number of <code class="computeroutput">item</code>s the to be inserted. </p></td> 3213</tr> 3214<tr> 3215<td><p><span class="term"><code class="computeroutput">pos</code></span></p></td> 3216<td><p>An iterator specifying the position where the <code class="computeroutput">item</code>s will be inserted. </p></td> 3217</tr> 3218</tbody> 3219</table></div></td> 3220</tr> 3221<tr> 3222<td><p><span class="term">Requires:</span></p></td> 3223<td><p><code class="computeroutput">pos</code> is a valid iterator pointing to the <code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code> or its end. </p></td> 3224</tr> 3225<tr> 3226<td><p><span class="term">Postconditions:</span></p></td> 3227<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> 3228The 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_buffer.html" title="Class template circular_buffer">circular_buffer</a></code>.<br> 3229(See <span class="emphasis"><em>Example</em></span> for the explanation.) </p></td> 3230</tr> 3231<tr> 3232<td><p><span class="term">Throws:</span></p></td> 3233<td>Whatever <code class="computeroutput">T::T(const T&)</code> throws. Whatever <code class="computeroutput">T::operator = (const T&)</code> throws. <a href="../circular_buffer/implementation.html#circular_buffer.implementation.exceptions_of_move_if_noexcept_t" target="_top">Exceptions of move_if_noexcept(T&)</a>. </td> 3234</tr> 3235</tbody> 3236</table></div> 3237</li> 3238<li class="listitem"> 3239<pre class="literallayout"><span class="keyword">template</span><span class="special"><</span><span class="keyword">typename</span> InputIterator<span class="special">></span> 3240 <span class="keyword">void</span> <a name="idm45227212905328-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> 3241 3242 3243 3244</p> 3245<p><b>Exception Safety. </b>Basic; no-throw if the operations in the <span class="emphasis"><em>Throws</em></span> section do not throw anything. </p> 3246<p> 3247</p> 3248<p><b>Iterator Invalidation. </b>Invalidates iterators pointing to the elements at the insertion point (including <code class="computeroutput">pos</code>) and iterators behind the insertion point (towards the end; except iterators equal to <code class="computeroutput">end()</code>). It also invalidates iterators pointing to the overwritten elements. </p> 3249<p> 3250</p> 3251<p><b>Complexity. </b>Linear (in <code class="computeroutput">[std::distance(pos, end()) + std::distance(first, last)]</code>; in <code class="computeroutput">min[capacity(), std::distance(pos, end()) + 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> 3252<p> 3253</p> 3254<p><b>Example. </b>Consider a <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code> with the capacity of 6 and the size of 4. Its internal buffer may look like the one below.<br> 3255<br> 3256 <code class="computeroutput">|1|2|3|4| | |</code><br> 3257 <code class="computeroutput">p ___^</code><br> 3258<br> 3259After inserting a range of elements at the position <code class="computeroutput">p</code>:<br> 3260<br> 3261 <code class="computeroutput">int array[] = { 5, 6, 7, 8, 9 };</code><br> 3262<code class="computeroutput">insert(p, array, array + 5);</code><br> 3263<br> 3264 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> 3265<br> 3266<code class="computeroutput">|6|7|8|9|3|4|</code><br> 3267<br> 3268For 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> 3269<p> 3270</p> 3271<p><span class="bold"><strong>See Also:</strong></span></p> 3272<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> 3273<p> 3274</p> 3275<p> 3276</p> 3277<div class="variablelist"><table border="0" class="variablelist compact"> 3278<colgroup> 3279<col align="left" valign="top"> 3280<col> 3281</colgroup> 3282<tbody> 3283<tr> 3284<td><p><span class="term">Parameters:</span></p></td> 3285<td><div class="variablelist"><table border="0" class="variablelist compact"> 3286<colgroup> 3287<col align="left" valign="top"> 3288<col> 3289</colgroup> 3290<tbody> 3291<tr> 3292<td><p><span class="term"><code class="computeroutput">first</code></span></p></td> 3293<td><p>The beginning of the range to be inserted. </p></td> 3294</tr> 3295<tr> 3296<td><p><span class="term"><code class="computeroutput">last</code></span></p></td> 3297<td><p>The end of the range to be inserted. </p></td> 3298</tr> 3299<tr> 3300<td><p><span class="term"><code class="computeroutput">pos</code></span></p></td> 3301<td><p>An iterator specifying the position where the range will be inserted. </p></td> 3302</tr> 3303</tbody> 3304</table></div></td> 3305</tr> 3306<tr> 3307<td><p><span class="term">Requires:</span></p></td> 3308<td><p><code class="computeroutput">pos</code> is a valid iterator pointing to the <code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code> or its end.<br> 3309 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> 3310</tr> 3311<tr> 3312<td><p><span class="term">Postconditions:</span></p></td> 3313<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> 3314The 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_buffer.html" title="Class template circular_buffer">circular_buffer</a></code>.<br> 3315(See <span class="emphasis"><em>Example</em></span> for the explanation.) </p></td> 3316</tr> 3317<tr> 3318<td><p><span class="term">Throws:</span></p></td> 3319<td>Whatever <code class="computeroutput">T::T(const T&)</code> throws if the <code class="computeroutput">InputIterator</code> is not a move iterator. Whatever <code class="computeroutput">T::operator = (const T&)</code> throws if the <code class="computeroutput">InputIterator</code> is not a move iterator. Whatever <code class="computeroutput">T::T(T&&)</code> throws if the <code class="computeroutput">InputIterator</code> is a move iterator. Whatever <code class="computeroutput">T::operator = (T&&)</code> throws if the <code class="computeroutput">InputIterator</code> is a move iterator. </td> 3320</tr> 3321</tbody> 3322</table></div> 3323</li> 3324<li class="listitem"> 3325<pre class="literallayout"><span class="identifier">iterator</span> <a name="idm45227212864960-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> 3326 3327 3328 3329 3330</p> 3331<p><b>Exception Safety. </b>Basic; no-throw if the operations in the <span class="emphasis"><em>Throws</em></span> section do not throw anything. </p> 3332<p> 3333</p> 3334<p><b>Iterator Invalidation. </b>Invalidates iterators pointing to the elements before the insertion point (towards the beginning and excluding <code class="computeroutput">pos</code>). It also invalidates iterators pointing to the overwritten element. </p> 3335<p> 3336</p> 3337<p><b>Complexity. </b>Linear (in <code class="computeroutput">std::distance(begin(), pos)</code>). </p> 3338<p> 3339</p> 3340<p><span class="bold"><strong>See Also:</strong></span></p> 3341<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> 3342<p> 3343</p> 3344<p> 3345</p> 3346<div class="variablelist"><table border="0" class="variablelist compact"> 3347<colgroup> 3348<col align="left" valign="top"> 3349<col> 3350</colgroup> 3351<tbody> 3352<tr> 3353<td><p><span class="term">Parameters:</span></p></td> 3354<td><div class="variablelist"><table border="0" class="variablelist compact"> 3355<colgroup> 3356<col align="left" valign="top"> 3357<col> 3358</colgroup> 3359<tbody> 3360<tr> 3361<td><p><span class="term"><code class="computeroutput">item</code></span></p></td> 3362<td><p>The element to be inserted. </p></td> 3363</tr> 3364<tr> 3365<td><p><span class="term"><code class="computeroutput">pos</code></span></p></td> 3366<td><p>An iterator specifying the position before which the <code class="computeroutput">item</code> will be inserted. </p></td> 3367</tr> 3368</tbody> 3369</table></div></td> 3370</tr> 3371<tr> 3372<td><p><span class="term">Requires:</span></p></td> 3373<td><p><code class="computeroutput">pos</code> is a valid iterator pointing to the <code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code> or its end. </p></td> 3374</tr> 3375<tr> 3376<td><p><span class="term">Postconditions:</span></p></td> 3377<td><p>The <code class="computeroutput">item</code> will be inserted before the position <code class="computeroutput">pos</code>.<br> 3378 If the <code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code> is full, the last element will be overwritten. If the <code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</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. </p></td> 3379</tr> 3380<tr> 3381<td><p><span class="term">Returns:</span></p></td> 3382<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> 3383</tr> 3384<tr> 3385<td><p><span class="term">Throws:</span></p></td> 3386<td>Whatever <code class="computeroutput">T::T(const T&)</code> throws. Whatever <code class="computeroutput">T::operator = (const T&)</code> throws. <a href="../circular_buffer/implementation.html#circular_buffer.implementation.exceptions_of_move_if_noexcept_t" target="_top">Exceptions of move_if_noexcept(T&)</a>. </td> 3387</tr> 3388</tbody> 3389</table></div> 3390</li> 3391<li class="listitem"> 3392<pre class="literallayout"><span class="identifier">iterator</span> <a name="idm45227212841088-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> 3393 3394 3395 3396 3397</p> 3398<p><b>Exception Safety. </b>Basic; no-throw if the operations in the <span class="emphasis"><em>Throws</em></span> section do not throw anything. </p> 3399<p> 3400</p> 3401<p><b>Iterator Invalidation. </b>Invalidates iterators pointing to the elements before the insertion point (towards the beginning and excluding <code class="computeroutput">pos</code>). It also invalidates iterators pointing to the overwritten element. </p> 3402<p> 3403</p> 3404<p><b>Complexity. </b>Linear (in <code class="computeroutput">std::distance(begin(), pos)</code>). </p> 3405<p> 3406</p> 3407<p><span class="bold"><strong>See Also:</strong></span></p> 3408<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> 3409<p> 3410</p> 3411<p> 3412</p> 3413<div class="variablelist"><table border="0" class="variablelist compact"> 3414<colgroup> 3415<col align="left" valign="top"> 3416<col> 3417</colgroup> 3418<tbody> 3419<tr> 3420<td><p><span class="term">Parameters:</span></p></td> 3421<td><div class="variablelist"><table border="0" class="variablelist compact"> 3422<colgroup> 3423<col align="left" valign="top"> 3424<col> 3425</colgroup> 3426<tbody> 3427<tr> 3428<td><p><span class="term"><code class="computeroutput">item</code></span></p></td> 3429<td><p>The element to be inserted. </p></td> 3430</tr> 3431<tr> 3432<td><p><span class="term"><code class="computeroutput">pos</code></span></p></td> 3433<td><p>An iterator specifying the position before which the <code class="computeroutput">item</code> will be inserted. </p></td> 3434</tr> 3435</tbody> 3436</table></div></td> 3437</tr> 3438<tr> 3439<td><p><span class="term">Requires:</span></p></td> 3440<td><p><code class="computeroutput">pos</code> is a valid iterator pointing to the <code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code> or its end. </p></td> 3441</tr> 3442<tr> 3443<td><p><span class="term">Postconditions:</span></p></td> 3444<td><p>The <code class="computeroutput">item</code> will be inserted before the position <code class="computeroutput">pos</code>.<br> 3445 If the <code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code> is full, the last element will be overwritten. If the <code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</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. </p></td> 3446</tr> 3447<tr> 3448<td><p><span class="term">Returns:</span></p></td> 3449<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> 3450</tr> 3451<tr> 3452<td><p><span class="term">Throws:</span></p></td> 3453<td>Whatever <code class="computeroutput">T::T(T&&)</code> throws. Whatever <code class="computeroutput">T::operator = (T&&)</code> throws. <a href="../circular_buffer/implementation.html#circular_buffer.implementation.exceptions_of_move_if_noexcept_t" target="_top">Exceptions of move_if_noexcept(T&)</a>. </td> 3454</tr> 3455</tbody> 3456</table></div> 3457</li> 3458<li class="listitem"> 3459<pre class="literallayout"><span class="identifier">iterator</span> <a name="idm45227212817232-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> 3460 3461 3462 3463 3464</p> 3465<p><b>Exception Safety. </b>Basic; no-throw if the operations in the <span class="emphasis"><em>Throws</em></span> section do not throw anything. </p> 3466<p> 3467</p> 3468<p><b>Iterator Invalidation. </b>Invalidates iterators pointing to the elements before the insertion point (towards the beginning and excluding <code class="computeroutput">pos</code>). It also invalidates iterators pointing to the overwritten element. </p> 3469<p> 3470</p> 3471<p><b>Complexity. </b>Linear (in <code class="computeroutput">std::distance(begin(), pos)</code>). </p> 3472<p> 3473</p> 3474<p><span class="bold"><strong>See Also:</strong></span></p> 3475<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> 3476<p> 3477</p> 3478<p> 3479</p> 3480<div class="variablelist"><table border="0" class="variablelist compact"> 3481<colgroup> 3482<col align="left" valign="top"> 3483<col> 3484</colgroup> 3485<tbody> 3486<tr> 3487<td><p><span class="term">Parameters:</span></p></td> 3488<td><div class="variablelist"><table border="0" class="variablelist compact"> 3489<colgroup> 3490<col align="left" valign="top"> 3491<col> 3492</colgroup> 3493<tbody><tr> 3494<td><p><span class="term"><code class="computeroutput">pos</code></span></p></td> 3495<td><p>An iterator specifying the position before which the <code class="computeroutput">item</code> will be inserted. </p></td> 3496</tr></tbody> 3497</table></div></td> 3498</tr> 3499<tr> 3500<td><p><span class="term">Requires:</span></p></td> 3501<td><p><code class="computeroutput">pos</code> is a valid iterator pointing to the <code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code> or its end. </p></td> 3502</tr> 3503<tr> 3504<td><p><span class="term">Postconditions:</span></p></td> 3505<td><p>The <code class="computeroutput">item</code> will be inserted before the position <code class="computeroutput">pos</code>.<br> 3506 If the <code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code> is full, the last element will be overwritten. If the <code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</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. </p></td> 3507</tr> 3508<tr> 3509<td><p><span class="term">Returns:</span></p></td> 3510<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> 3511</tr> 3512<tr> 3513<td><p><span class="term">Throws:</span></p></td> 3514<td>Whatever <code class="computeroutput">T::T()</code> throws. Whatever <code class="computeroutput">T::T(T&&)</code> throws. Whatever <code class="computeroutput">T::operator = (T&&)</code> throws. <a href="../circular_buffer/implementation.html#circular_buffer.implementation.exceptions_of_move_if_noexcept_t" target="_top">Exceptions of move_if_noexcept(T&)</a>. </td> 3515</tr> 3516</tbody> 3517</table></div> 3518</li> 3519<li class="listitem"> 3520<pre class="literallayout"><span class="keyword">void</span> <a name="idm45227212794048-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> 3521 3522 3523 3524</p> 3525<p><b>Exception Safety. </b>Basic; no-throw if the operations in the <span class="emphasis"><em>Throws</em></span> section do not throw anything. </p> 3526<p> 3527</p> 3528<p><b>Iterator Invalidation. </b>Invalidates iterators pointing to the elements before the insertion point (towards the beginning and excluding <code class="computeroutput">pos</code>). It also invalidates iterators pointing to the overwritten elements. </p> 3529<p> 3530</p> 3531<p><b>Complexity. </b>Linear (in <code class="computeroutput">min[capacity(), std::distance(begin(), pos) + n]</code>). </p> 3532<p> 3533</p> 3534<p><b>Example. </b>Consider a <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code> with the capacity of 6 and the size of 4. Its internal buffer may look like the one below.<br> 3535<br> 3536 <code class="computeroutput">|1|2|3|4| | |</code><br> 3537 <code class="computeroutput">p ___^</code><br> 3538<br> 3539After inserting 5 elements before the position <code class="computeroutput">p</code>:<br> 3540<br> 3541 <code class="computeroutput">rinsert(p, (size_t)5, 0);</code><br> 3542<br> 3543actually 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> 3544<br> 3545<code class="computeroutput">|1|2|0|0|0|0|</code><br> 3546 <br> 3547For 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> 3548<p> 3549</p> 3550<p><span class="bold"><strong>See Also:</strong></span></p> 3551<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> 3552<p> 3553</p> 3554<p> 3555</p> 3556<div class="variablelist"><table border="0" class="variablelist compact"> 3557<colgroup> 3558<col align="left" valign="top"> 3559<col> 3560</colgroup> 3561<tbody> 3562<tr> 3563<td><p><span class="term">Parameters:</span></p></td> 3564<td><div class="variablelist"><table border="0" class="variablelist compact"> 3565<colgroup> 3566<col align="left" valign="top"> 3567<col> 3568</colgroup> 3569<tbody> 3570<tr> 3571<td><p><span class="term"><code class="computeroutput">item</code></span></p></td> 3572<td><p>The element whose copies will be inserted. </p></td> 3573</tr> 3574<tr> 3575<td><p><span class="term"><code class="computeroutput">n</code></span></p></td> 3576<td><p>The number of <code class="computeroutput">item</code>s the to be inserted. </p></td> 3577</tr> 3578<tr> 3579<td><p><span class="term"><code class="computeroutput">pos</code></span></p></td> 3580<td><p>An iterator specifying the position where the <code class="computeroutput">item</code>s will be inserted. </p></td> 3581</tr> 3582</tbody> 3583</table></div></td> 3584</tr> 3585<tr> 3586<td><p><span class="term">Requires:</span></p></td> 3587<td><p><code class="computeroutput">pos</code> is a valid iterator pointing to the <code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code> or its end. </p></td> 3588</tr> 3589<tr> 3590<td><p><span class="term">Postconditions:</span></p></td> 3591<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> 3592The 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_buffer.html" title="Class template circular_buffer">circular_buffer</a></code>.<br> 3593(See <span class="emphasis"><em>Example</em></span> for the explanation.) </p></td> 3594</tr> 3595<tr> 3596<td><p><span class="term">Throws:</span></p></td> 3597<td>Whatever <code class="computeroutput">T::T(const T&)</code> throws. Whatever <code class="computeroutput">T::operator = (const T&)</code> throws. <a href="../circular_buffer/implementation.html#circular_buffer.implementation.exceptions_of_move_if_noexcept_t" target="_top">Exceptions of move_if_noexcept(T&)</a>. </td> 3598</tr> 3599</tbody> 3600</table></div> 3601</li> 3602<li class="listitem"> 3603<pre class="literallayout"><span class="keyword">template</span><span class="special"><</span><span class="keyword">typename</span> InputIterator<span class="special">></span> 3604 <span class="keyword">void</span> <a name="idm45227212762208-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> 3605 3606 3607 3608</p> 3609<p><b>Exception Safety. </b>Basic; no-throw if the operations in the <span class="emphasis"><em>Throws</em></span> section do not throw anything. </p> 3610<p> 3611</p> 3612<p><b>Iterator Invalidation. </b>Invalidates iterators pointing to the elements before the insertion point (towards the beginning and excluding <code class="computeroutput">pos</code>). It also invalidates iterators pointing to the overwritten elements. </p> 3613<p> 3614</p> 3615<p><b>Complexity. </b>Linear (in <code class="computeroutput">[std::distance(begin(), pos) + std::distance(first, last)]</code>; in <code class="computeroutput">min[capacity(), std::distance(begin(), pos) + 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> 3616<p> 3617</p> 3618<p><b>Example. </b>Consider a <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code> with the capacity of 6 and the size of 4. Its internal buffer may look like the one below.<br> 3619<br> 3620 <code class="computeroutput">|1|2|3|4| | |</code><br> 3621 <code class="computeroutput">p ___^</code><br> 3622<br> 3623After inserting a range of elements before the position <code class="computeroutput">p</code>:<br> 3624<br> 3625 <code class="computeroutput">int array[] = { 5, 6, 7, 8, 9 };</code><br> 3626<code class="computeroutput">insert(p, array, array + 5);</code><br> 3627<br> 3628 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> 3629<br> 3630<code class="computeroutput">|1|2|5|6|7|8|</code><br> 3631<br> 3632For 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> 3633<p> 3634</p> 3635<p><span class="bold"><strong>See Also:</strong></span></p> 3636<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> 3637<p> 3638</p> 3639<p> 3640</p> 3641<div class="variablelist"><table border="0" class="variablelist compact"> 3642<colgroup> 3643<col align="left" valign="top"> 3644<col> 3645</colgroup> 3646<tbody> 3647<tr> 3648<td><p><span class="term">Parameters:</span></p></td> 3649<td><div class="variablelist"><table border="0" class="variablelist compact"> 3650<colgroup> 3651<col align="left" valign="top"> 3652<col> 3653</colgroup> 3654<tbody> 3655<tr> 3656<td><p><span class="term"><code class="computeroutput">first</code></span></p></td> 3657<td><p>The beginning of the range to be inserted. </p></td> 3658</tr> 3659<tr> 3660<td><p><span class="term"><code class="computeroutput">last</code></span></p></td> 3661<td><p>The end of the range to be inserted. </p></td> 3662</tr> 3663<tr> 3664<td><p><span class="term"><code class="computeroutput">pos</code></span></p></td> 3665<td><p>An iterator specifying the position where the range will be inserted. </p></td> 3666</tr> 3667</tbody> 3668</table></div></td> 3669</tr> 3670<tr> 3671<td><p><span class="term">Requires:</span></p></td> 3672<td><p><code class="computeroutput">pos</code> is a valid iterator pointing to the <code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code> or its end.<br> 3673 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> 3674</tr> 3675<tr> 3676<td><p><span class="term">Postconditions:</span></p></td> 3677<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> 3678The 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> 3679(See <span class="emphasis"><em>Example</em></span> for the explanation.) </p></td> 3680</tr> 3681<tr> 3682<td><p><span class="term">Throws:</span></p></td> 3683<td>Whatever <code class="computeroutput">T::T(const T&)</code> throws if the <code class="computeroutput">InputIterator</code> is not a move iterator. Whatever <code class="computeroutput">T::operator = (const T&)</code> throws if the <code class="computeroutput">InputIterator</code> is not a move iterator. Whatever <code class="computeroutput">T::T(T&&)</code> throws if the <code class="computeroutput">InputIterator</code> is a move iterator. Whatever <code class="computeroutput">T::operator = (T&&)</code> throws if the <code class="computeroutput">InputIterator</code> is a move iterator. </td> 3684</tr> 3685</tbody> 3686</table></div> 3687</li> 3688<li class="listitem"> 3689<pre class="literallayout"><span class="identifier">iterator</span> <a name="idm45227212722288-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> 3690 3691 3692 3693 3694</p> 3695<p><b>Exception Safety. </b>Basic; no-throw if the operation in the <span class="emphasis"><em>Throws</em></span> section does not throw anything. </p> 3696<p> 3697</p> 3698<p><b>Iterator Invalidation. </b>Invalidates iterators pointing to the erased element and iterators pointing to the elements behind the erased element (towards the end; except iterators equal to <code class="computeroutput">end()</code>). </p> 3699<p> 3700</p> 3701<p><b>Complexity. </b>Linear (in <code class="computeroutput">std::distance(pos, end())</code>). </p> 3702<p> 3703</p> 3704<p><span class="bold"><strong>See Also:</strong></span></p> 3705<p><code class="computeroutput">erase(iterator, iterator)</code>, <code class="computeroutput">rerase(iterator)</code>, <code class="computeroutput">rerase(iterator, iterator)</code>, <code class="computeroutput">erase_begin(size_type)</code>, <code class="computeroutput">erase_end(size_type)</code>, <code class="computeroutput">clear()</code> </p> 3706<p> 3707</p> 3708<p> 3709</p> 3710<div class="variablelist"><table border="0" class="variablelist compact"> 3711<colgroup> 3712<col align="left" valign="top"> 3713<col> 3714</colgroup> 3715<tbody> 3716<tr> 3717<td><p><span class="term">Parameters:</span></p></td> 3718<td><div class="variablelist"><table border="0" class="variablelist compact"> 3719<colgroup> 3720<col align="left" valign="top"> 3721<col> 3722</colgroup> 3723<tbody><tr> 3724<td><p><span class="term"><code class="computeroutput">pos</code></span></p></td> 3725<td><p>An iterator pointing at the element to be removed. </p></td> 3726</tr></tbody> 3727</table></div></td> 3728</tr> 3729<tr> 3730<td><p><span class="term">Requires:</span></p></td> 3731<td><p><code class="computeroutput">pos</code> is a valid iterator pointing to the <code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code> (but not an <code class="computeroutput">end()</code>). </p></td> 3732</tr> 3733<tr> 3734<td><p><span class="term">Postconditions:</span></p></td> 3735<td><p>The element at the position <code class="computeroutput">pos</code> is removed. </p></td> 3736</tr> 3737<tr> 3738<td><p><span class="term">Returns:</span></p></td> 3739<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> 3740</tr> 3741<tr> 3742<td><p><span class="term">Throws:</span></p></td> 3743<td><a href="circular_buffer/implementation.html#circular_buffer.implementation.exceptions_of_move_if_noexcept_t">Exceptions of move_if_noexcept(T&). </td> 3744</tr> 3745</tbody> 3746</table></div> 3747</li> 3748<li class="listitem"> 3749<pre class="literallayout"><span class="identifier">iterator</span> <a name="idm45227212705952-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> 3750 3751 3752 3753 3754</p> 3755<p><b>Exception Safety. </b>Basic; no-throw if the operation in the <span class="emphasis"><em>Throws</em></span> section does not throw anything. </p> 3756<p> 3757</p> 3758<p><b>Iterator Invalidation. </b>Invalidates iterators pointing to the erased elements and iterators pointing to the elements behind the erased range (towards the end; except iterators equal to <code class="computeroutput">end()</code>). </p> 3759<p> 3760</p> 3761<p><b>Complexity. </b>Linear (in <code class="computeroutput">std::distance(first, end())</code>). </p> 3762<p> 3763</p> 3764<p><span class="bold"><strong>See Also:</strong></span></p> 3765<p><code class="computeroutput">erase(iterator)</code>, <code class="computeroutput">rerase(iterator)</code>, <code class="computeroutput">rerase(iterator, iterator)</code>, <code class="computeroutput">erase_begin(size_type)</code>, <code class="computeroutput">erase_end(size_type)</code>, <code class="computeroutput">clear()</code> </p> 3766<p> 3767</p> 3768<p> 3769</p> 3770<div class="variablelist"><table border="0" class="variablelist compact"> 3771<colgroup> 3772<col align="left" valign="top"> 3773<col> 3774</colgroup> 3775<tbody> 3776<tr> 3777<td><p><span class="term">Parameters:</span></p></td> 3778<td><div class="variablelist"><table border="0" class="variablelist compact"> 3779<colgroup> 3780<col align="left" valign="top"> 3781<col> 3782</colgroup> 3783<tbody> 3784<tr> 3785<td><p><span class="term"><code class="computeroutput">first</code></span></p></td> 3786<td><p>The beginning of the range to be removed. </p></td> 3787</tr> 3788<tr> 3789<td><p><span class="term"><code class="computeroutput">last</code></span></p></td> 3790<td><p>The end of the range to be removed. </p></td> 3791</tr> 3792</tbody> 3793</table></div></td> 3794</tr> 3795<tr> 3796<td><p><span class="term">Requires:</span></p></td> 3797<td><p>Valid range <code class="computeroutput">[first, last)</code>. </p></td> 3798</tr> 3799<tr> 3800<td><p><span class="term">Postconditions:</span></p></td> 3801<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.) </p></td> 3802</tr> 3803<tr> 3804<td><p><span class="term">Returns:</span></p></td> 3805<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> 3806</tr> 3807<tr> 3808<td><p><span class="term">Throws:</span></p></td> 3809<td><a href="circular_buffer/implementation.html#circular_buffer.implementation.exceptions_of_move_if_noexcept_t">Exceptions of move_if_noexcept(T&). </td> 3810</tr> 3811</tbody> 3812</table></div> 3813</li> 3814<li class="listitem"> 3815<pre class="literallayout"><span class="identifier">iterator</span> <a name="idm45227212688800-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> 3816 3817 3818 3819 3820</p> 3821<p><b>Exception Safety. </b>Basic; no-throw if the operation in the <span class="emphasis"><em>Throws</em></span> section does not throw anything. </p> 3822<p> 3823</p> 3824<p><b>Iterator Invalidation. </b>Invalidates iterators pointing to the erased element and iterators pointing to the elements in front of the erased element (towards the beginning). </p> 3825<p> 3826</p> 3827<p><b>Complexity. </b>Linear (in <code class="computeroutput">std::distance(begin(), pos)</code>). </p> 3828<p> 3829</p> 3830<div class="note"><table border="0" summary="Note"> 3831<tr> 3832<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../doc/src/images/note.png"></td> 3833<th align="left">Note</th> 3834</tr> 3835<tr><td align="left" valign="top"><p>This method is symmetric to the <code class="computeroutput">erase(iterator)</code> method and is more effective than <code class="computeroutput">erase(iterator)</code> if the iterator <code class="computeroutput">pos</code> is close to the beginning of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code>. (See the <span class="emphasis"><em>Complexity</em></span>.) </p></td></tr> 3836</table></div> 3837<p> 3838</p> 3839<p><span class="bold"><strong>See Also:</strong></span></p> 3840<p><code class="computeroutput">erase(iterator)</code>, <code class="computeroutput">erase(iterator, iterator)</code>, <code class="computeroutput">rerase(iterator, iterator)</code>, <code class="computeroutput">erase_begin(size_type)</code>, <code class="computeroutput">erase_end(size_type)</code>, <code class="computeroutput">clear()</code> </p> 3841<p> 3842</p> 3843<p> 3844</p> 3845<div class="variablelist"><table border="0" class="variablelist compact"> 3846<colgroup> 3847<col align="left" valign="top"> 3848<col> 3849</colgroup> 3850<tbody> 3851<tr> 3852<td><p><span class="term">Parameters:</span></p></td> 3853<td><div class="variablelist"><table border="0" class="variablelist compact"> 3854<colgroup> 3855<col align="left" valign="top"> 3856<col> 3857</colgroup> 3858<tbody><tr> 3859<td><p><span class="term"><code class="computeroutput">pos</code></span></p></td> 3860<td><p>An iterator pointing at the element to be removed. </p></td> 3861</tr></tbody> 3862</table></div></td> 3863</tr> 3864<tr> 3865<td><p><span class="term">Requires:</span></p></td> 3866<td><p><code class="computeroutput">pos</code> is a valid iterator pointing to the <code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code> (but not an <code class="computeroutput">end()</code>). </p></td> 3867</tr> 3868<tr> 3869<td><p><span class="term">Postconditions:</span></p></td> 3870<td><p>The element at the position <code class="computeroutput">pos</code> is removed. </p></td> 3871</tr> 3872<tr> 3873<td><p><span class="term">Returns:</span></p></td> 3874<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> 3875</tr> 3876<tr> 3877<td><p><span class="term">Throws:</span></p></td> 3878<td><a href="circular_buffer/implementation.html#circular_buffer.implementation.exceptions_of_move_if_noexcept_t">Exceptions of move_if_noexcept(T&). </td> 3879</tr> 3880</tbody> 3881</table></div> 3882</li> 3883<li class="listitem"> 3884<pre class="literallayout"><span class="identifier">iterator</span> <a name="idm45227212669488-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> 3885 3886 3887 3888 3889</p> 3890<p><b>Exception Safety. </b>Basic; no-throw if the operation in the <span class="emphasis"><em>Throws</em></span> section does not throw anything. </p> 3891<p> 3892</p> 3893<p><b>Iterator Invalidation. </b>Invalidates iterators pointing to the erased elements and iterators pointing to the elements in front of the erased range (towards the beginning). </p> 3894<p> 3895</p> 3896<p><b>Complexity. </b>Linear (in <code class="computeroutput">std::distance(begin(), last)</code>). </p> 3897<p> 3898</p> 3899<div class="note"><table border="0" summary="Note"> 3900<tr> 3901<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../doc/src/images/note.png"></td> 3902<th align="left">Note</th> 3903</tr> 3904<tr><td align="left" valign="top"><p>This method is symmetric to the <code class="computeroutput">erase(iterator, iterator)</code> method and is more effective than <code class="computeroutput">erase(iterator, iterator)</code> if <code class="computeroutput">std::distance(begin(), first)</code> is lower that <code class="computeroutput">std::distance(last, end())</code>. </p></td></tr> 3905</table></div> 3906<p> 3907</p> 3908<p><span class="bold"><strong>See Also:</strong></span></p> 3909<p><code class="computeroutput">erase(iterator)</code>, <code class="computeroutput">erase(iterator, iterator)</code>, <code class="computeroutput">rerase(iterator)</code>, <code class="computeroutput">erase_begin(size_type)</code>, <code class="computeroutput">erase_end(size_type)</code>, <code class="computeroutput">clear()</code> </p> 3910<p> 3911</p> 3912<p> 3913</p> 3914<div class="variablelist"><table border="0" class="variablelist compact"> 3915<colgroup> 3916<col align="left" valign="top"> 3917<col> 3918</colgroup> 3919<tbody> 3920<tr> 3921<td><p><span class="term">Parameters:</span></p></td> 3922<td><div class="variablelist"><table border="0" class="variablelist compact"> 3923<colgroup> 3924<col align="left" valign="top"> 3925<col> 3926</colgroup> 3927<tbody> 3928<tr> 3929<td><p><span class="term"><code class="computeroutput">first</code></span></p></td> 3930<td><p>The beginning of the range to be removed. </p></td> 3931</tr> 3932<tr> 3933<td><p><span class="term"><code class="computeroutput">last</code></span></p></td> 3934<td><p>The end of the range to be removed. </p></td> 3935</tr> 3936</tbody> 3937</table></div></td> 3938</tr> 3939<tr> 3940<td><p><span class="term">Requires:</span></p></td> 3941<td><p>Valid range <code class="computeroutput">[first, last)</code>. </p></td> 3942</tr> 3943<tr> 3944<td><p><span class="term">Postconditions:</span></p></td> 3945<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.) </p></td> 3946</tr> 3947<tr> 3948<td><p><span class="term">Returns:</span></p></td> 3949<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> 3950</tr> 3951<tr> 3952<td><p><span class="term">Throws:</span></p></td> 3953<td><a href="circular_buffer/implementation.html#circular_buffer.implementation.exceptions_of_move_if_noexcept_t">Exceptions of move_if_noexcept(T&). </td> 3954</tr> 3955</tbody> 3956</table></div> 3957</li> 3958<li class="listitem"> 3959<pre class="literallayout"><span class="keyword">void</span> <a name="idm45227212650160-bb"></a><span class="identifier">erase_begin</span><span class="special">(</span><span class="identifier">size_type</span> n<span class="special">)</span><span class="special">;</span></pre>Remove first <code class="computeroutput">n</code> elements (with constant complexity for scalar types). <p> 3960 3961 3962 3963</p> 3964<p><b>Exception Safety. </b>Basic; no-throw if the operation in the <span class="emphasis"><em>Throws</em></span> section does not throw anything. (I.e. no throw in case of scalars.) </p> 3965<p> 3966</p> 3967<p><b>Iterator Invalidation. </b>Invalidates iterators pointing to the first <code class="computeroutput">n</code> erased elements. </p> 3968<p> 3969</p> 3970<p><b>Complexity. </b>Constant (in <code class="computeroutput">n</code>) for scalar types; linear for other types. </p> 3971<p> 3972</p> 3973<div class="note"><table border="0" summary="Note"> 3974<tr> 3975<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../doc/src/images/note.png"></td> 3976<th align="left">Note</th> 3977</tr> 3978<tr><td align="left" valign="top"><p>This method has been specially designed for types which do not require an explicit destructruction (e.g. integer, float or a pointer). For these scalar types a call to a destructor is not required which makes it possible to implement the "erase from beginning" operation with a constant complexity. For non-sacalar types the complexity is linear (hence the explicit destruction is needed) and the implementation is actually equivalent to <code class="computeroutput">rerase(begin(), begin() + n)</code>. </p></td></tr> 3979</table></div> 3980<p> 3981</p> 3982<p><span class="bold"><strong>See Also:</strong></span></p> 3983<p><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>, <code class="computeroutput">erase_end(size_type)</code>, <code class="computeroutput">clear()</code> </p> 3984<p> 3985</p> 3986<p> 3987</p> 3988<div class="variablelist"><table border="0" class="variablelist compact"> 3989<colgroup> 3990<col align="left" valign="top"> 3991<col> 3992</colgroup> 3993<tbody> 3994<tr> 3995<td><p><span class="term">Parameters:</span></p></td> 3996<td><div class="variablelist"><table border="0" class="variablelist compact"> 3997<colgroup> 3998<col align="left" valign="top"> 3999<col> 4000</colgroup> 4001<tbody><tr> 4002<td><p><span class="term"><code class="computeroutput">n</code></span></p></td> 4003<td><p>The number of elements to be removed. </p></td> 4004</tr></tbody> 4005</table></div></td> 4006</tr> 4007<tr> 4008<td><p><span class="term">Requires:</span></p></td> 4009<td><p><code class="computeroutput">n <= size()</code> </p></td> 4010</tr> 4011<tr> 4012<td><p><span class="term">Postconditions:</span></p></td> 4013<td><p>The <code class="computeroutput">n</code> elements at the beginning of the <code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code> will be removed. </p></td> 4014</tr> 4015<tr> 4016<td><p><span class="term">Throws:</span></p></td> 4017<td><a href="circular_buffer/implementation.html#circular_buffer.implementation.exceptions_of_move_if_noexcept_t">Exceptions of move_if_noexcept(T&). </td> 4018</tr> 4019</tbody> 4020</table></div> 4021</li> 4022<li class="listitem"> 4023<pre class="literallayout"><span class="keyword">void</span> <a name="idm45227212633392-bb"></a><span class="identifier">erase_end</span><span class="special">(</span><span class="identifier">size_type</span> n<span class="special">)</span><span class="special">;</span></pre>Remove last <code class="computeroutput">n</code> elements (with constant complexity for scalar types). <p> 4024 4025 4026 4027</p> 4028<p><b>Exception Safety. </b>Basic; no-throw if the operation in the <span class="emphasis"><em>Throws</em></span> section does not throw anything. (I.e. no throw in case of scalars.) </p> 4029<p> 4030</p> 4031<p><b>Iterator Invalidation. </b>Invalidates iterators pointing to the last <code class="computeroutput">n</code> erased elements. </p> 4032<p> 4033</p> 4034<p><b>Complexity. </b>Constant (in <code class="computeroutput">n</code>) for scalar types; linear for other types. </p> 4035<p> 4036</p> 4037<div class="note"><table border="0" summary="Note"> 4038<tr> 4039<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../doc/src/images/note.png"></td> 4040<th align="left">Note</th> 4041</tr> 4042<tr><td align="left" valign="top"><p>This method has been specially designed for types which do not require an explicit destructruction (e.g. integer, float or a pointer). For these scalar types a call to a destructor is not required which makes it possible to implement the "erase from end" operation with a constant complexity. For non-sacalar types the complexity is linear (hence the explicit destruction is needed) and the implementation is actually equivalent to <code class="computeroutput">erase(end() - n, end())</code>. </p></td></tr> 4043</table></div> 4044<p> 4045</p> 4046<p><span class="bold"><strong>See Also:</strong></span></p> 4047<p><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>, <code class="computeroutput">erase_begin(size_type)</code>, <code class="computeroutput">clear()</code> </p> 4048<p> 4049</p> 4050<p> 4051</p> 4052<div class="variablelist"><table border="0" class="variablelist compact"> 4053<colgroup> 4054<col align="left" valign="top"> 4055<col> 4056</colgroup> 4057<tbody> 4058<tr> 4059<td><p><span class="term">Parameters:</span></p></td> 4060<td><div class="variablelist"><table border="0" class="variablelist compact"> 4061<colgroup> 4062<col align="left" valign="top"> 4063<col> 4064</colgroup> 4065<tbody><tr> 4066<td><p><span class="term"><code class="computeroutput">n</code></span></p></td> 4067<td><p>The number of elements to be removed. </p></td> 4068</tr></tbody> 4069</table></div></td> 4070</tr> 4071<tr> 4072<td><p><span class="term">Requires:</span></p></td> 4073<td><p><code class="computeroutput">n <= size()</code> </p></td> 4074</tr> 4075<tr> 4076<td><p><span class="term">Postconditions:</span></p></td> 4077<td><p>The <code class="computeroutput">n</code> elements at the end of the <code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code> will be removed. </p></td> 4078</tr> 4079<tr> 4080<td><p><span class="term">Throws:</span></p></td> 4081<td><a href="circular_buffer/implementation.html#circular_buffer.implementation.exceptions_of_move_if_noexcept_t">Exceptions of move_if_noexcept(T&). </td> 4082</tr> 4083</tbody> 4084</table></div> 4085</li> 4086<li class="listitem"> 4087<pre class="literallayout"><span class="keyword">void</span> <a name="idm45227212616640-bb"></a><span class="identifier">clear</span><span class="special">(</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span></pre>Remove all stored elements from the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code>. <p> 4088 4089</p> 4090<p><b>Exception Safety. </b>No-throw. </p> 4091<p> 4092</p> 4093<p><b>Iterator Invalidation. </b>Invalidates all iterators pointing to the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code> (except iterators equal to <code class="computeroutput">end()</code>). </p> 4094<p> 4095</p> 4096<p><b>Complexity. </b>Constant (in the size of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code>) for scalar types; linear for other types. </p> 4097<p> 4098</p> 4099<p><span class="bold"><strong>See Also:</strong></span></p> 4100<p><code class="computeroutput">~circular_buffer()</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>, <code class="computeroutput">erase_begin(size_type)</code>, <code class="computeroutput">erase_end(size_type)</code> </p> 4101<p> 4102</p> 4103<p> 4104</p> 4105<div class="variablelist"><table border="0" class="variablelist compact"> 4106<colgroup> 4107<col align="left" valign="top"> 4108<col> 4109</colgroup> 4110<tbody> 4111<tr> 4112<td><p><span class="term">Postconditions:</span></p></td> 4113<td><p><code class="computeroutput">size() == 0</code> </p></td> 4114</tr> 4115<tr> 4116<td><p><span class="term">Throws:</span></p></td> 4117<td>Nothing. </td> 4118</tr> 4119</tbody> 4120</table></div> 4121</li> 4122</ol></div> 4123</div> 4124</div> 4125</div> 4126<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr> 4127<td align="left"></td> 4128<td align="right"><div class="copyright-footer">Copyright © 2003-2013 Jan Gaspar<p> 4129 Distributed under the Boost Software License, Version 1.0. (See accompanying 4130 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>) 4131 </p> 4132</div></td> 4133</tr></table> 4134<hr> 4135<div class="spirit-nav"> 4136<a accesskey="p" href="../BOOST_CB_ENABLE_DEBUG.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.base_hpp"><img src="../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="operator_idm45227212472336.html"><img src="../../../doc/src/images/next.png" alt="Next"></a> 4137</div> 4138</body> 4139</html> 4140
