hash_set.html

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

<P>The member function returns true for an empty controlled sequence.</P>

<H3><CODE><A NAME="hash_multiset::end">hash_multiset::end</A></CODE></H3>

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

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

<H3><CODE><A NAME="hash_multiset::equal_range">hash_multiset::equal_range</A></CODE></H3>

<PRE>pair&lt;const_iterator, const_iterator&gt;
    <B>equal_range</B>(const Key&amp; keyval) const;</PRE>

<P>The member function returns a pair of iterators <CODE>X</CODE>
such that <CODE>X.<A HREF="utility.html#pair::first">first</A> ==
<A HREF="#hash_multiset::lower_bound">lower_bound</A>(keyval)</CODE>
and <CODE>X.<A HREF="utility.html#pair::second">second</A> ==
<A HREF="#hash_multiset::upper_bound">upper_bound</A>(keyval)</CODE>.</P>

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

<PRE>iterator <B>erase</B>(iterator where);
iterator <B>erase</B>(iterator first, iterator last);
size_type <B>erase</B>(const Key&amp; keyval);</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
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="#hash_multiset::end">end</A>()</CODE> if no such element exists.</P>

<P>The third member removes
the elements with sort keys in the range
<CODE>[<A HREF="#hash_multiset::lower_bound">lower_bound</A>(keyval),
<A HREF="#hash_multiset::upper_bound">upper_bound</A>(keyval)).</CODE>
It returns the number of elements it removes.</P>

<P>The member functions never throw an exception.</P>

<H3><CODE><A NAME="hash_multiset::find">hash_multiset::find</A></CODE></H3>

<PRE>const_iterator <B>find</B>(const Key&amp; keyval) const;</PRE>

<P>The member function returns
<CODE><A HREF="#hash_multiset::lower_bound">lower_bound</A>(keyval)</CODE>.</P>

<H3><CODE><A NAME="hash_multiset::get_allocator">hash_multiset::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="hash_multiset::hash_multiset">hash_multiset::hash_multiset</A></CODE></H3>

<PRE><B>hash_multiset</B>();
explicit <B>hash_multiset</B>(const Tr&amp; traits);
<B>hash_multiset</B>(const Tr&amp; traits, const Alloc&amp; al);
<B>hash_multiset</B>(const hash_multiset&amp; right);
template&lt;class InIt&gt;
    <B>hash_multiset</B>(InIt first, InIt last);
template&lt;class InIt&gt;
    <B>hash_multiset</B>(InIt first, InIt last,
        const Tr&amp; traits);
template&lt;class InIt&gt;
    <B>hash_multiset</B>(InIt first, InIt last,
        const Tr&amp; traits, const Alloc&amp; al);</PRE>

<P>All constructors store an
<A HREF="memory.html#allocator object">allocator object</A> and
initialize the controlled sequence. The allocator object is the argument
<CODE>al</CODE>, if present. For the copy constructor, it is
<CODE>right.<A HREF="#hash_multiset::get_allocator">get_allocator</A>()</CODE>.
Otherwise, it is <CODE>Alloc()</CODE>.</P>

<P>All constructors also store a
<A HREF="hash_map.html#hash traits">hash traits</A> object that can later
be returned by calling
<CODE><A HREF="#hash_multiset::key_comp">key_comp</A>()</CODE>.
The hash traits object is the argument <CODE>traits</CODE>, if present.
For the copy constructor, it is
<CODE>right.<A HREF="#hash_multiset::key_comp">key_comp</A>()</CODE>).
Otherwise, it is <CODE>Tr()</CODE>.</P>

<P>The first three constructors specify an
empty initial controlled sequence. The fourth constructor specifies
a copy of the sequence controlled by <CODE>right</CODE>.
The last three constructors specify the sequence of element values
<CODE>[first, last)</CODE>.</P>


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

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

<P>The first member function inserts the element <CODE>val</CODE>
in the controlled sequence, then returns
the iterator that designates the inserted element.
The second member function returns <CODE>insert(val)</CODE>,
using <CODE>where</CODE> as a starting place within the controlled
sequence to search for the insertion point. (Insertion can
possibly occur somewhat faster, if the
insertion point immediately precedes or follows <CODE>where</CODE>.)
The third member function
inserts the sequence of element values,
for each <CODE>where</CODE> in the range <CODE>[first, last)</CODE>,
by calling <CODE>insert(*where)</CODE>.</P>


<P>If an exception is thrown during the
insertion of a single element, the container is left unaltered
and the exception is rethrown.
If an exception is thrown during the
insertion of multiple elements, the container is left in a stable
but unspecified state and the exception is rethrown.</P>

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

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

<P>The type describes an object that can serve as a bidirectional
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="hash_multiset::key_comp">hash_multiset::key_comp</A></CODE></H3>

<PRE>key_compare <B>key_comp</B>() const;</PRE>

<P>The member function returns the stored
<A HREF="hash_map.html#hash traits">hash traits</A> object that
determines the order of elements in the controlled sequence.
In particular, the stored object defines the member function:</P>

<PRE>bool operator()(const Key&amp; left, const Key&amp; right);</PRE>

<P>which returns true if <CODE>left</CODE> strictly
precedes <CODE>right</CODE> in the sort order.</P>

<H3><CODE><A NAME="hash_multiset::key_compare">hash_multiset::key_compare</A></CODE></H3>

<PRE>typedef Tr <B>key_compare</B>;</PRE>

<P>The type describes a traits object that behaves much like an object of class
<CODE><A HREF="hash_map.html#hash_compare">hash_compare</A>&lt;Key, Pr&gt;</CODE>.
In particular, it can compare two
sort keys to determine the relative order of two
elements in the controlled sequence.</P>

<H3><CODE><A NAME="hash_multiset::key_type">hash_multiset::key_type</A></CODE></H3>

<PRE>typedef Key <B>key_type</B>;</PRE>

<P>The type describes the sort key object which constitutes each
element of the controlled sequence.</P>

<H3><CODE><A NAME="hash_multiset::lower_bound">hash_multiset::lower_bound</A></CODE></H3>

<PRE>const_iterator <B>lower_bound</B>(const Key&amp; keyval) const;</PRE>

<P>The member function returns an iterator that designates the
earliest element <CODE>X</CODE> in the controlled sequence
for which <CODE>X</CODE> has
<A HREF="lib_stl.html#equivalent ordering">equivalent ordering</A>
to <CODE>keyval</CODE>, as well as the same hash value.
(This is generally uninteresting, except that the interval
<CODE>[lower_bound(keyval), upper_bound(keyval))</CODE> does
delimit all elements with equivalent ordering to <CODE>keyval</CODE>.)
If no such element exists, the function returns
<CODE><A HREF="#hash_multiset::end">end</A>()</CODE>.

<H3><CODE><A NAME="hash_multiset::max_size">hash_multiset::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="hash_multiset::pointer">hash_multiset::pointer</A></CODE></H3>

<PRE>typedef 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="hash_multiset::rbegin">hash_multiset::rbegin</A></CODE></H3>

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

<P>The member function returns a reverse bidirectional
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="hash_multiset::reference">hash_multiset::reference</A></CODE></H3>

<PRE>typedef 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="hash_multiset::rend">hash_multiset::rend</A></CODE></H3>

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

<P>The member function returns a reverse bidirectional
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="hash_multiset::reverse_iterator">hash_multiset::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
bidirectional iterator for the controlled sequence.</P>

<H3><CODE><A NAME="hash_multiset::size">hash_multiset::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="hash_multiset::size_type">hash_multiset::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="hash_multiset::swap">hash_multiset::swap</A></CODE></H3>

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

<P>The member function swaps the controlled sequences between
<CODE>*this</CODE> and <CODE>right</CODE>. If
<CODE><A HREF="#hash_multiset::get_allocator">get_allocator</A>()
== right.get_allocator()</CODE>, it does so in constant time,
it throws an exception only as a result of copying the stored
traits object of type <CODE>Tr</CODE>, 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="hash_multiset::upper_bound">hash_multiset::upper_bound</A></CODE></H3>

<PRE>const_iterator <B>upper_bound</B>(const Key&amp; keyval) const;</PRE>

<P>The member function returns an iterator
just beyond the iterator that designates the
latest element <CODE>X</CODE> in the controlled sequence
for which <CODE>X</CODE> has
<A HREF="lib_stl.html#equivalent ordering">equivalent ordering</A>
to <CODE>keyval</CODE>.
If no such element exists, the function returns
<CODE><A HREF="#hash_multiset::end">end</A>()</CODE>.

<H3><CODE><A NAME="hash_multiset::value_comp">hash_multiset::value_comp</A></CODE></H3>

<PRE>value_compare <B>value_comp</B>() const;</PRE>

<P>The member function returns a function object that
determines the order of elements in the controlled sequence.</P>

<H3><CODE><A NAME="hash_multiset::value_compare">hash_multiset::value_compare</A></CODE></H3>

<PRE>typedef Tr <B>value_compare</B>;</PRE>

<P>The type describes a function object that can compare two
elements as sort keys to determine their relative order
in the controlled sequence.</P>

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

<PRE>typedef Key <B>value_type</B>;</PRE>

<P>The type describes an element of the controlled sequence.</P>

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

<HR>
<P><B><CODE><A HREF="#hash_set::allocator_type">allocator_type</A>
&#183; <A HREF="#hash_set::begin">begin</A>
&#183; <A HREF="#hash_set::clear">clear</A>
&#183; <A HREF="#hash_set::const_iterator">const_iterator</A>
&#183; <A HREF="#hash_set::const_pointer">const_pointer</A>
&#183; <A HREF="#hash_set::const_reference">const_reference</A>
&#183; <A HREF="#hash_set::const_reverse_iterator">const_reverse_iterator</A>
&#183; <A HREF="#hash_set::count">count</A>
&#183; <A HREF="#hash_set::difference_type">difference_type</A>
&#183; <A HREF="#hash_set::empty">empty</A>
&#183; <A HREF="#hash_set::end">end</A>
&#183; <A HREF="#hash_set::equal_range">equal_range</A>
&#183; <A HREF="#hash_set::erase">erase</A>
&#183; <A HREF="#hash_set::find">find</A>
&#183; <A HREF="#hash_set::get_allocator">get_allocator</A>
&#183; <A HREF="#hash_set::insert">insert</A>
&#183; <A HREF="#hash_set::iterator">iterator</A>
&#183; <A HREF="#hash_set::key_comp">key_comp</A>
&#183; <A HREF="#hash_set::key_compare">key_compare</A>
&#183; <A HREF="#hash_set::key_type">key_type</A>
&#183; <A HREF="#hash_set::lower_bound">lower_bound</A>
&#183; <A HREF="#hash_set::max_size">max_size</A>