deque.html

ST20 Embedded Toolset R2.0.5用于开发基于ST20芯片机顶盒软件的开发平台,2.0.5版本,国内找不到的.在国外论坛上花了N天才找到!

<PRE>const_iterator <B>end</B>() const;
iterator <B>end</B>();</PRE>

<P>The member function returns a random-access iterator that points
just beyond the end of the sequence.</P>

<H3><CODE><A NAME="deque::erase">deque::erase</A></CODE></H3>

<PRE>iterator <B>erase</B>(iterator where);
iterator <B>erase</B>(iterator first, iterator last);</PRE>

<P>The first member function removes the element of the controlled
sequence pointed to by <CODE>where</CODE>. The second member function
removes the elements of the controlled sequence
in the range <CODE>[first, last)</CODE>.
Both return an iterator that designates the first element remaining
beyond any elements removed, or
<CODE><A HREF="#deque::end">end</A>()</CODE> if no such element exists.</P>

<P>Removing <CODE>N</CODE> elements causes <CODE>N</CODE> destructor calls
and an assignment for each of the elements between the insertion
point and the nearer end of the sequence.
Removing an element at either end
<A HREF="#invalid deque iterators">invalidates</A> only iterators and
references that designate the erased elements. Otherwise,
erasing an element invalidates all iterators and references.</P>

<P>The member functions throw an exception only if a copy operation
throws an exception.</P>

<H3><CODE><A NAME="deque::front">deque::front</A></CODE></H3>

<PRE>reference <B>front</B>();
const_reference <B>front</B>() const;</PRE>

<P>The member function returns a reference to the first element of the
controlled sequence, which must be non-empty.</P>

<H3><CODE><A NAME="deque::get_allocator">deque::get_allocator</A></CODE></H3>

<PRE>Alloc <B>get_allocator</B>() const;</PRE>

<P>The member function returns the stored
<A HREF="memory.html#allocator object">allocator object</A>.</P>

<H3><CODE><A NAME="deque::insert">deque::insert</A></CODE></H3>

<PRE>iterator <B>insert</B>(iterator where, const Ty&amp; val);
void <B>insert</B>(iterator where, size_type count, const Ty&amp; val);
template&lt;class InIt&gt;
    void <B>insert</B>(iterator where, InIt first, InIt last);</PRE>

<P>Each of the member functions inserts, before the element pointed to
by <CODE>where</CODE> in the controlled sequence, a sequence
specified by the remaining operands.
The first member function inserts
a single element with value <CODE>val</CODE> and returns an iterator
that designates the newly inserted element.
The second member function
inserts a repetition of <CODE>count</CODE> elements of value <CODE>val</CODE>.

<P>If <CODE>InIt</CODE> is an integer type, the last member
function behaves the same as <CODE>insert(where, (size_type)first, (Ty)last)</CODE>.
Otherwise, the
last member function inserts the sequence
<CODE>[first, last)</CODE>, which must <I>not</I> overlap
the initial controlled sequence.</P>


<P>When inserting a single element, the number of
element copies is linear in the number of elements between the insertion
point and the nearer end of the sequence. When inserting a single element
at either end of the sequence, the amortized number of element copies
is constant. When inserting <CODE>N</CODE> elements,
the number of element copies is linear in
<CODE>N</CODE> plus the number of elements between the insertion
point and the nearer end of the sequence -- except when the template member
is specialized for <CODE>InIt</CODE> an input or forward iterator, which
behaves like <CODE>N</CODE> single insertions.
Inserting an element at either end
<A HREF="#invalid deque iterators">invalidates</A> all iterators,
but no references, that designate existing elements. Otherwise,
inserting an element invalidates all iterators and references.</P>

<P>If an exception is thrown during the
insertion of one or more elements, and the exception is not thrown while
copying an element, the container is left unaltered
and the exception is rethrown.</P>

<H3><CODE><A NAME="deque::iterator">deque::iterator</A></CODE></H3>

<PRE>typedef T0 <B>iterator</B>;</PRE>

<P>The type describes an object that can serve as a random-access
iterator for the controlled sequence.
It is described here as a
synonym for the implementation-defined type <CODE>T0</CODE>.</P>

<H3><CODE><A NAME="deque::max_size">deque::max_size</A></CODE></H3>

<PRE>size_type <B>max_size</B>() const;</PRE>

<P>The member function returns the length of the longest sequence that
the object can control.</P>

<H3><CODE><A NAME="deque::operator[]">deque::operator[]</A></CODE></H3>

<PRE>const_reference <B>operator[]</B>(size_type pos) const;
reference <B>operator[]</B>(size_type pos);</PRE>

<P>The member function returns a reference to the element of the
controlled sequence at position <CODE>pos</CODE>. If that position is
invalid, the behavior is undefined.</P>

<H3><CODE><A NAME="deque::pointer">deque::pointer</A></CODE></H3>

<PRE>typedef typename Alloc::pointer <B>pointer</B>;</PRE>

<P>The type describes an object that can serve as a pointer to an
element of the controlled sequence.</P>

<H3><CODE><A NAME="deque::pop_back">deque::pop_back</A></CODE></H3>

<PRE>void <B>pop_back</B>();</PRE>

<P>The member function removes the last element of the
controlled sequence, which must be non-empty.
Removing the element
<A HREF="#invalid deque iterators">invalidates</A> only iterators and
references that designate the erased element.</P>

<P>The member function never throws an exception.</P>

<H3><CODE><A NAME="deque::pop_front">deque::pop_front</A></CODE></H3>

<PRE>void <B>pop_front</B>();</PRE>

<P>The member function removes the first element of the
controlled sequence, which must be non-empty.
Removing the element
<A HREF="#invalid deque iterators">invalidates</A> only iterators and
references that designate the erased element.</P>

<P>The member function never throws an exception.</P>

<H3><CODE><A NAME="deque::push_back">deque::push_back</A></CODE></H3>

<PRE>void <B>push_back</B>(const Ty&amp; val);</PRE>

<P>The member function inserts an element with value <CODE>val</CODE>
at the end of the controlled sequence. Inserting the element
<A HREF="#invalid deque iterators">invalidates</A> all iterators,
but no references, to existing elements.</P>

<P>If an exception is thrown, the container is left unaltered
and the exception is rethrown.</P>

<H3><CODE><A NAME="deque::push_front">deque::push_front</A></CODE></H3>

<PRE>void <B>push_front</B>(const Ty&amp; val);</PRE>

<P>The member function inserts an element with value <CODE>val</CODE>
at the beginning of the controlled sequence. Inserting the element
<A HREF="#invalid deque iterators">invalidates</A> all iterators,
but no references, to existing elements.</P>

<P>If an exception is thrown, the container is left unaltered
and the exception is rethrown.</P>

<H3><CODE><A NAME="deque::rbegin">deque::rbegin</A></CODE></H3>

<PRE>const_reverse_iterator <B>rbegin</B>() const;
reverse_iterator <B>rbegin</B>();</PRE>

<P>The member function returns a reverse iterator that points just
beyond the end of the controlled sequence. Hence, it designates the
beginning of the reverse sequence.</P>

<H3><CODE><A NAME="deque::reference">deque::reference</A></CODE></H3>

<PRE>typedef typename Alloc::reference <B>reference</B>;</PRE>

<P>The type describes an object that can serve as a reference to an
element of the controlled sequence.</P>

<H3><CODE><A NAME="deque::rend">deque::rend</A></CODE></H3>

<PRE>const_reverse_iterator <B>rend</B>() const;
reverse_iterator <B>rend</B>();</PRE>

<P>The member function returns a reverse iterator that points at the
first element of the sequence (or just beyond the end of an empty
sequence). Hence, it designates the end of the reverse sequence.</P>

<H3><CODE><A NAME="deque::resize">deque::resize</A></CODE></H3>

<PRE>void <B>resize</B>(size_type newsize);
void <B>resize</B>(size_type newsize, Ty val);</PRE>

<P>The member functions both ensure that
<CODE><A HREF="#deque::size">size</A>()</CODE> henceforth
returns <CODE>newsize</CODE>. If it must make the controlled sequence longer,
the first member function
appends elements with value <CODE>Ty()</CODE>, while the second member function
appends elements with value <CODE>val</CODE>.
To make the controlled sequence shorter, both member functions call
<CODE><A HREF="#deque::erase">erase</A>(begin() + newsize, end())</CODE>.</P>

<H3><CODE><A NAME="deque::reverse_iterator">deque::reverse_iterator</A></CODE></H3>

<PRE>typedef reverse_iterator&lt;iterator&gt;
    <B>reverse_iterator</B>;</PRE>

<P>The type describes an object that can serve as a reverse
random-access iterator for the controlled sequence.</P>

<H3><CODE><A NAME="deque::size">deque::size</A></CODE></H3>

<PRE>size_type <B>size</B>() const;</PRE>

<P>The member function returns the length of the controlled sequence.</P>

<H3><CODE><A NAME="deque::size_type">deque::size_type</A></CODE></H3>

<PRE>typedef T2 <B>size_type</B>;</PRE>

<P>The unsigned integer type describes an object that can represent the
length of any controlled sequence. It is described here as a
synonym for the implementation-defined type <CODE>T2</CODE>.</P>

<H3><CODE><A NAME="deque::swap">deque::swap</A></CODE></H3>

<PRE>void <B>swap</B>(deque&amp; right);</PRE>

<P>The member function swaps the controlled sequences between
<CODE>*this</CODE> and <CODE>right</CODE>. If
<CODE><A HREF="#deque::get_allocator">get_allocator</A>()
== right.get_allocator()</CODE>, it does so in constant time,
it throws no exceptions, and it invalidates no references, pointers,
or iterators that designate elements in the two controlled sequences.
Otherwise, it performs a number of element assignments and constructor calls
proportional to the number of elements in the two controlled sequences.</P>

<H3><CODE><A NAME="deque::value_type">deque::value_type</A></CODE></H3>

<PRE>typedef typename Alloc::value_type <B>value_type</B>;</PRE>

<P>The type is a synonym for the template parameter <CODE>Ty</CODE>.</P>

<H2><A NAME="operator!="><CODE>operator!=</CODE></A></H2>

<PRE>template&lt;class Ty, class Alloc&gt;
    bool <B>operator!=</B>(
        const deque &lt;Ty, Alloc&gt;&amp; left,
        const deque &lt;Ty, Alloc&gt;&amp; right);</PRE>

<P>The template function returns <CODE>!(left == right)</CODE>.</P>

<H2><A NAME="operator=="><CODE>operator==</CODE></A></H2>

<PRE>template&lt;class Ty, class Alloc&gt;
    bool <B>operator==</B>(
        const deque &lt;Ty, Alloc&gt;&amp; left,
        const deque &lt;Ty, Alloc&gt;&amp; right);</PRE>

<P>The template function overloads <CODE>operator==</CODE> to compare
two objects of template class
<A HREF="#deque"><CODE>deque</CODE></A>. The function returns
<CODE>left.<A HREF="#deque::size">size</A>() == right.size() &amp;&amp;
<A HREF="algorith.html#equal">equal</A>(left.
<A HREF="#deque::begin">begin</A>(), left.
<A HREF="#deque::end">end</A>(), right.begin())</CODE>.</P>

<H2><A NAME="operator&lt;"><CODE>operator&lt;</CODE></A></H2>

<PRE>template&lt;class Ty, class Alloc&gt;
    bool <B>operator&lt;</B>(
        const deque &lt;Ty, Alloc&gt;&amp; left,
        const deque &lt;Ty, Alloc&gt;&amp; right);</PRE>

<P>The template function overloads <CODE>operator&lt;</CODE> to compare
two objects of template class
<A HREF="#deque"><CODE>deque</CODE></A>. The function returns
<CODE><A HREF="algorith.html#lexicographical_compare">lexicographical_compare</A>(left.
<A HREF="#deque::begin">begin</A>(), left.
<A HREF="#deque::end">end</A>(), right.begin(), right.end())</CODE>.</P>

<H2><A NAME="operator&lt;="><CODE>operator&lt;=</CODE></A></H2>

<PRE>template&lt;class Ty, class Alloc&gt;
    bool <B>operator&lt;=</B>(
        const deque &lt;Ty, Alloc&gt;&amp; left,
        const deque &lt;Ty, Alloc&gt;&amp; right);</PRE>

<P>The template function returns <CODE>!(right &lt; left)</CODE>.</P>

<H2><A NAME="operator&gt;"><CODE>operator&gt;</CODE></A></H2>

<PRE>template&lt;class Ty, class Alloc&gt;
    bool <B>operator&gt;</B>(
        const deque &lt;Ty, Alloc&gt;&amp; left,
        const deque &lt;Ty, Alloc&gt;&amp; right);</PRE>

<P>The template function returns <CODE>right &lt; left</CODE>.</P>

<H2><A NAME="operator&gt;="><CODE>operator&gt;=</CODE></A></H2>

<PRE>template&lt;class Ty, class Alloc&gt;
    bool <B>operator&gt;=</B>(
        const deque &lt;Ty, Alloc&gt;&amp; left,
        const deque &lt;Ty, Alloc&gt;&amp; right);</PRE>

<P>The template function returns <CODE>!(left &lt; right)</CODE>.</P>

<H2><A NAME="swap"><CODE>swap</CODE></A></H2>

<PRE>template&lt;class Ty, class Alloc&gt;
    void <B>swap</B>(
        deque &lt;Ty, Alloc&gt;&amp; left,
        deque &lt;Ty, Alloc&gt;&amp; right);</PRE>

<P>The template function executes
<CODE>left.<A HREF="#deque::swap">swap</A>(right)</CODE>.</P>

<HR>
<P>See also the
<B><A HREF="index.html#Table of Contents">Table of Contents</A></B> and the
<B><A HREF="_index.html">Index</A></B>.</P>

<P><I>
<A HREF="crit_pjp.html">Copyright</A> &#169; 1994-2002
by P.J. Plauger. Portions derived from work
<A HREF="crit_hp.html">copyright</A> &#169; 1994
by Hewlett-Packard Company. All rights reserved.</I></P>

<!--V4.01:1125--></BODY></HTML>