stl_map.h

来自「symbian上STL模板库的实现」· C头文件 代码 · 共 696 行 · 第 1/3 页

                         iterator
                             begin()
                             { return _M_t.begin(); }

                         /**
                          *  Returns a read-only (constant) iterator that points to the first pair
                          *  in the %map.  Iteration is done in ascending order according to the
                          *  keys.
                          */
                         const_iterator
                             begin() const
                             { return _M_t.begin(); }

                         /**
                          *  Returns a read/write iterator that points one past the last pair in
                          *  the %map.  Iteration is done in ascending order according to the keys.
                          */
                         iterator
                             end()
                             { return _M_t.end(); }

                         /**
                          *  Returns a read-only (constant) iterator that points one past the last
                          *  pair in the %map.  Iteration is done in ascending order according to
                          *  the keys.
                          */
                         const_iterator
                             end() const
                             { return _M_t.end(); }

                         /**
                          *  Returns a read/write reverse iterator that points to the last pair in
                          *  the %map.  Iteration is done in descending order according to the
                          *  keys.
                          */
                         reverse_iterator
                             rbegin()
                             { return _M_t.rbegin(); }

                         /**
                          *  Returns a read-only (constant) reverse iterator that points to the
                          *  last pair in the %map.  Iteration is done in descending order
                          *  according to the keys.
                          */
                         const_reverse_iterator
                             rbegin() const
                             { return _M_t.rbegin(); }

                         /**
                          *  Returns a read/write reverse iterator that points to one before the
                          *  first pair in the %map.  Iteration is done in descending order
                          *  according to the keys.
                          */
                         reverse_iterator
                             rend()
                             { return _M_t.rend(); }

                         /**
                          *  Returns a read-only (constant) reverse iterator that points to one
                          *  before the first pair in the %map.  Iteration is done in descending
                          *  order according to the keys.
                          */
                         const_reverse_iterator
                             rend() const
                             { return _M_t.rend(); }

                         // capacity
                         /** Returns true if the %map is empty.  (Thus begin() would equal
                          *  end().)
                          */
                         bool
                             empty() const
                             { return _M_t.empty(); }

                         /** Returns the size of the %map.  */
                         size_type
                             size() const
                             { return _M_t.size(); }

                         /** Returns the maximum size of the %map.  */
                         size_type
                             max_size() const
                             { return _M_t.max_size(); }

                         // [23.3.1.2] element access
                         /**
                          *  @brief  Subscript ( @c [] ) access to %map data.
                          *  @param  k  The key for which data should be retrieved.
                          *  @return  A reference to the data of the (key,data) %pair.
                          *
                          *  Allows for easy lookup with the subscript ( @c [] ) operator.  Returns
                          *  data associated with the key specified in subscript.  If the key does
                          *  not exist, a pair with that key is created using default values, which
                          *  is then returned.
                          *
                          *  Lookup requires logarithmic time.
                          */
                         mapped_type&
                             operator[](const key_type& __k)
                             {
                                 // concept requirements
#ifndef NO__GLIBCXX_FUNCTION_REQUIRES
                                 __glibcxx_function_requires(_DefaultConstructibleConcept<mapped_type>)
#endif
                                     iterator __i = lower_bound(__k);
                                 // __i->first is greater than or equivalent to __k.
                                 if (__i == end() || key_comp()(__k, (*__i).first))
                                     __i = insert(__i, value_type(__k, mapped_type()));
                                 return (*__i).second;
                             }

                         // modifiers
                         /**
                          *  @brief Attempts to insert a std::pair into the %map.
                          *  @param  x  Pair to be inserted (see std::make_pair for easy creation of
                          *             pairs).
                          *  @return  A pair, of which the first element is an iterator that points
                          *           to the possibly inserted pair, and the second is a bool that
                          *           is true if the pair was actually inserted.
                          *
                          *  This function attempts to insert a (key, value) %pair into the %map.
                          *  A %map relies on unique keys and thus a %pair is only inserted if its
                          *  first element (the key) is not already present in the %map.
                          *
                          *  Insertion requires logarithmic time.
                          */
                         pair<iterator,bool>
                             insert(const value_type& __x)
                             { return _M_t.insert_unique(__x); }

                         /**
                          *  @brief Attempts to insert a std::pair into the %map.
                          *  @param  position  An iterator that serves as a hint as to where the
                          *                    pair should be inserted.
                          *  @param  x  Pair to be inserted (see std::make_pair for easy creation of
                          *             pairs).
                          *  @return  An iterator that points to the element with key of @a x (may
                          *           or may not be the %pair passed in).
                          *
                          *  This function is not concerned about whether the insertion took place,
                          *  and thus does not return a boolean like the single-argument
                          *  insert() does.  Note that the first parameter is only a hint and can
                          *  potentially improve the performance of the insertion process.  A bad
                          *  hint would cause no gains in efficiency.
                          *
                          *  See http://gcc.gnu.org/onlinedocs/libstdc++/23_containers/howto.html#4
                          *  for more on "hinting".
                          *
                          *  Insertion requires logarithmic time (if the hint is not taken).
                          */
                         iterator
                             insert(iterator position, const value_type& __x)
                             { return _M_t.insert_unique(position, __x); }

                         /**
                          *  @brief A template function that attemps to insert a range of elements.
                          *  @param  first  Iterator pointing to the start of the range to be
                          *                 inserted.
                          *  @param  last  Iterator pointing to the end of the range.
                          *
                          *  Complexity similar to that of the range constructor.
                          */
                         template <typename _InputIterator>
                             void
                             insert(_InputIterator __first, _InputIterator __last)
                             { _M_t.insert_unique(__first, __last); }

                         /**
                          *  @brief Erases an element from a %map.
                          *  @param  position  An iterator pointing to the element to be erased.
                          *
                          *  This function erases an element, pointed to by the given iterator,
                          *  from a %map.  Note that this function only erases the element, and
                          *  that if the element is itself a pointer, the pointed-to memory is not
                          *  touched in any way.  Managing the pointer is the user's responsibilty.
                          */
                         void
                             erase(iterator __position)
                             { _M_t.erase(__position); }

                         /**
                          *  @brief Erases elements according to the provided key.
                          *  @param  x  Key of element to be erased.
                          *  @return  The number of elements erased.
                          *
                          *  This function erases all the elements located by the given key from
                          *  a %map.
                          *  Note that this function only erases the element, and that if
                          *  the element is itself a pointer, the pointed-to memory is not touched
                          *  in any way.  Managing the pointer is the user's responsibilty.
                          */
                         size_type
                             erase(const key_type& __x)
                             { return _M_t.erase(__x); }

                         /**
                          *  @brief Erases a [first,last) range of elements from a %map.
                          *  @param  first  Iterator pointing to the start of the range to be
                          *                 erased.
                          *  @param  last  Iterator pointing to the end of the range to be erased.
                          *
                          *  This function erases a sequence of elements from a %map.
                          *  Note that this function only erases the element, and that if
                          *  the element is itself a pointer, the pointed-to memory is not touched
                          *  in any way.  Managing the pointer is the user's responsibilty.
                          */
                         void
                             erase(iterator __first, iterator __last)
                             { _M_t.erase(__first, __last); }

                         /**
                          *  @brief  Swaps data with another %map.
                          *  @param  x  A %map of the same element and allocator types.
                          *
                          *  This exchanges the elements between two maps in constant time.
                          *  (It is only swapping a pointer, an integer, and an instance of
                          *  the @c Compare type (which itself is often stateless and empty), so it
                          *  should be quite fast.)
                          *  Note that the global std::swap() function is specialized such that
                          *  std::swap(m1,m2) will feed to this function.
                          */
                         void
                             swap(map& __x)
                             { _M_t.swap(__x._M_t); }

                         /**
                          *  Erases all elements in a %map.  Note that this function only erases
                          *  the elements, and that if the elements themselves are pointers, the
                          *  pointed-to memory is not touched in any way.  Managing the pointer is
                          *  the user's responsibilty.
                          */
                         void