hash_map.html

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

<CODE><A HREF="#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_multimap::key_type">hash_multimap::key_type</A></CODE></H3>

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

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

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

<PRE>iterator <B>lower_bound</B>(const Key&amp; keyval);
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><A HREF="#hash_multimap::key_comp">key_comp</A>()(X.
<A HREF="utility.html#pair::first">first</A>, keyval)</CODE> is
false.</P> If no such element exists, the function returns
<CODE><A HREF="#hash_multimap::end">end</A>()</CODE>.

<H3><CODE><A NAME="hash_multimap::mapped_type">hash_multimap::mapped_type</A></CODE></H3>

<PRE>typedef Ty <B>mapped_type</B>;</PRE>

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

<H3><CODE><A NAME="hash_multimap::max_size">hash_multimap::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_multimap::pointer">hash_multimap::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_multimap::rbegin">hash_multimap::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 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_multimap::reference">hash_multimap::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_multimap::rend">hash_multimap::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 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_multimap::reverse_iterator">hash_multimap::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_multimap::size">hash_multimap::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_multimap::size_type">hash_multimap::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_multimap::swap">hash_multimap::swap</A></CODE></H3>

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

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

<PRE>iterator <B>upper_bound</B>(const Key&amp; keyval);
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.<A HREF="utility.html#pair::first">first</A></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_multimap::end">end</A>()</CODE>.

<H3><CODE><A NAME="hash_multimap::value_comp">hash_multimap::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_multimap::value_compare">hash_multimap::value_compare</A></CODE></H3>

<PRE>class <B>value_compare</B>
    : public <A HREF="functio2.html#binary_function">binary_function</A>&lt;value_type, value_type,
        bool&gt; {
public:
    bool operator()(const value_type&amp; left,
        const value_type&amp; right) const
        {return (comp(left.first, right.first)); }
protected:
    value_compare(key_compare pr)
        : comp(pr) {}
    key_compare comp;
    };</PRE>

<P>The type describes a function object that can compare the
sort keys in two elements to determine their relative order
in the controlled sequence. The function object stores an object
<B><CODE><A NAME="hash_multimap::value_compare::comp">comp</A></CODE></B>
of type <CODE><A HREF="#hash_multimap::key_type">key_type</A></CODE>.
The member function <B><CODE>operator()</CODE></B> uses this
object to compare the sort-key components of two element.</P>

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

<PRE>typedef <A HREF="utility.html#pair">pair</A>&lt;const Key, Ty&gt; <B>value_type</B>;
</PRE>

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

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

<PRE>template&lt;class Key, class Ty, class Tr, class Alloc&gt;
    bool <B>operator!=</B>(
        const hash_map &lt;Key, Ty, Tr, Alloc&gt;&amp; left,
        const hash_map &lt;Key, Ty, Tr, Alloc&gt;&amp; right);
template&lt;class Key, class Ty, class Tr, class Alloc&gt;
    bool <B>operator!=</B>(
        const hash_multimap &lt;Key, Ty, Tr, Alloc&gt;&amp; left,
        const hash_multimap &lt;Key, Ty, 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 Ty, class Tr, class Alloc&gt;
    bool <B>operator==</B>(
        const hash_map &lt;Key, Ty, Tr, Alloc&gt;&amp; left,
        const hash_map &lt;Key, Ty, Tr, Alloc&gt;&amp; right);
template&lt;class Key, class Ty, class Tr, class Alloc&gt;
    bool <B>operator==</B>(
        const hash_multimap &lt;Key, Ty, Tr, Alloc&gt;&amp; left,
        const hash_multimap &lt;Key, Ty, 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_map"><CODE>hash_map</CODE></A>.
The second template function overloads <CODE>operator==</CODE>
to compare two objects of template class
<A HREF="#hash_multimap"><CODE>hash_multimap</CODE></A>.
Both functions return
<CODE>left.<A HREF="#hash_multimap::size">size</A>() == right.size() &amp;&amp;
<A HREF="algorith.html#equal">equal</A>(left.
<A HREF="#hash_multimap::begin">begin</A>(), left.
<A HREF="#hash_multimap::end">end</A>(), right.begin())</CODE>.</P>

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

<PRE>template&lt;class Key, class Ty, class Tr, class Alloc&gt;
    bool <B>operator&lt;</B>(
        const hash_map &lt;Key, Ty, Tr, Alloc&gt;&amp; left,
        const hash_map &lt;Key, Ty, Tr, Alloc&gt;&amp; right);
template&lt;class Key, class Ty, class Tr, class Alloc&gt;
    bool <B>operator&lt;</B>(
        const hash_multimap &lt;Key, Ty, Tr, Alloc&gt;&amp; left,
        const hash_multimap &lt;Key, Ty, 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_map"><CODE>hash_map</CODE></A>.
The second template function overloads <CODE>operator&lt;</CODE>
to compare two objects of template class
<A HREF="#hash_multimap"><CODE>hash_multimap</CODE></A>.
Both functions return
<CODE><A HREF="algorith.html#lexicographical_compare">lexicographical_compare</A>(left.
<A HREF="#hash_multimap::begin">begin</A>(), left.
<A HREF="#hash_multimap::end">end</A>(), right.begin(), right.end(),
left.<A HREF="#hash_multimap::value_comp">value_comp</A>())</CODE>.</P>

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

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

<P>The template function executes
<CODE>left.<A HREF="#hash_map::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; 1998-2002
by P.J. Plauger. All rights reserved.</I></P>

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