hash_set.html

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

to <CODE>val</CODE>. If not, it creates such
an element <CODE>X</CODE> and initializes it with <CODE>val</CODE>.
The function then determines the iterator <CODE>where</CODE> that
designates <CODE>X</CODE>. If an insertion occurred, the function
returns <CODE><A HREF="utility.html#pair">pair</A>(where, true)</CODE>.
Otherwise, it returns <CODE>pair(where, false)</CODE>.</P>

<P>The second member function returns <CODE>insert(val).first</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_set::iterator">hash_set::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_set::key_comp">hash_set::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_set::key_compare">hash_set::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_set::key_type">hash_set::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_set::lower_bound">hash_set::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>.
If no such element exists, the function returns
<CODE><A HREF="#hash_set::end">end</A>()</CODE>.

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

<PRE>typedef Alloc::const_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_set::rbegin">hash_set::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_set::reference">hash_set::reference</A></CODE></H3>

<PRE>typedef Alloc::const_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_set::rend">hash_set::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_set::reverse_iterator">hash_set::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_set::size">hash_set::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_set::size_type">hash_set::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_set::swap">hash_set::swap</A></CODE></H3>

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

<P>The member function swaps the controlled sequences between
<CODE>*this</CODE> and <CODE>right</CODE>. If
<CODE><A HREF="#hash_set::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_set::upper_bound">hash_set::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_set::end">end</A>()</CODE>.

<H3><CODE><A NAME="hash_set::value_comp">hash_set::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_set::value_compare">hash_set::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_set::value_type">hash_set::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="swap"><CODE>swap</CODE></A></H2>

<PRE>template&lt;class Key, class Tr, class Alloc&gt;
    void <B>swap</B>(
        hash_multiset &lt;Key, Tr, Alloc&gt;&amp; left,
        hash_multiset &lt;Key, Tr, Alloc&gt;&amp; right);
template&lt;class Key, class Tr, class Alloc&gt;
    void <B>swap</B>(
        hash_set &lt;Key, Tr, Alloc&gt;&amp; left,
        hash_set &lt;Key, Tr, Alloc&gt;&amp; right);</PRE>

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

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

<PRE>template&lt;class Key, class Tr, class Alloc&gt;
    bool <B>operator!=</B>(
        const hash_set &lt;Key, Tr, Alloc&gt;&amp; left,
        const hash_set &lt;Key, Tr, Alloc&gt;&amp; right);
template&lt;class Key, class Tr, class Alloc&gt;
    bool <B>operator!=</B>(
        const hash_multiset &lt;Key, Tr, Alloc&gt;&amp; left,
        const hash_multiset &lt;Key, Tr, 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 Key, class Tr, class Alloc&gt;
    bool <B>operator==</B>(
        const hash_set &lt;Key, Tr, Alloc&gt;&amp; left,
        const hash_set &lt;Key, Tr, Alloc&gt;&amp; right);
template&lt;class Key, class Tr, class Alloc&gt;
    bool <B>operator==</B>(
        const hash_multiset &lt;Key, Tr, Alloc&gt;&amp; left,
        const hash_multiset &lt;Key, Tr, Alloc&gt;&amp; right);</PRE>

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

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

<PRE>template&lt;class Key, class Tr, class Alloc&gt;
    bool <B>operator&lt;</B>(
        const hash_set &lt;Key, Tr, Alloc&gt;&amp; left,
        const hash_set &lt;Key, Tr, Alloc&gt;&amp; right);
template&lt;class Key, class Tr, class Alloc&gt;
    bool <B>operator&lt;</B>(
        const hash_multiset &lt;Key, Tr, Alloc&gt;&amp; left,
        const hash_multiset &lt;Key, Tr, Alloc&gt;&amp; right);</PRE>

<P>The first template function overloads <CODE>operator&lt;</CODE>
to compare two objects of template class
<A HREF="#hash_set"><CODE>hash_set</CODE></A>.
The second template function overloads <CODE>operator&lt;</CODE>
to compare two objects of template class
<A HREF="#hash_multiset"><CODE>hash_multiset</CODE></A>.
Both functions return
<CODE><A HREF="algorith.html#lexicographical_compare">lexicographical_compare</A>(left.
<A HREF="#hash_multiset::begin">begin</A>(), left.
<A HREF="#hash_multiset::end">end</A>(), right.begin(), right.end(),
left.<A HREF="#hash_multiset::value_comp">value_comp</A>())</CODE>.</P>

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

<PRE>template&lt;class Key, class Tr, class Alloc&gt;
    bool <B>operator&lt;=</B>(
        const hash_set &lt;Key, Tr, Alloc&gt;&amp; left,
        const hash_set &lt;Key, Tr, Alloc&gt;&amp; right);
template&lt;class Key, class Tr, class Alloc&gt;
    bool <B>operator&lt;=</B>(
        const hash_multiset &lt;Key, Tr, Alloc&gt;&amp; left,
        const hash_multiset &lt;Key, Tr, 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 Key, class Tr, class Alloc&gt;
    bool <B>operator&gt;</B>(
        const hash_set &lt;Key, Tr, Alloc&gt;&amp; left,
        const hash_set &lt;Key, Tr, Alloc&gt;&amp; right);
template&lt;class Key, class Tr, class Alloc&gt;
    bool <B>operator&gt;</B>(
        const hash_multiset &lt;Key, Tr, Alloc&gt;&amp; left,
        const hash_multiset &lt;Key, Tr, 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 Key, class Tr, class Alloc&gt;
    bool <B>operator&gt;=</B>(
        const hash_set &lt;Key, Tr, Alloc&gt;&amp; left,
        const hash_set &lt;Key, Tr, Alloc&gt;&amp; right);
template&lt;class Key, class Tr, class Alloc&gt;
    bool <B>operator&gt;=</B>(
        const hash_multiset &lt;Key, Tr, Alloc&gt;&amp; left,
        const hash_multiset &lt;Key, Tr, Alloc&gt;&amp; right);</PRE>

<P>The template function returns <CODE>!(left &lt; 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; 1998-2002
by P.J. Plauger. All rights reserved.</I></P>

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