stl_vector.h

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

         */
        iterator
            begin() { return iterator (this->_M_impl._M_start); }

        /**
         *  Returns a read-only (constant) iterator that points to the
         *  first element in the %vector.  Iteration is done in ordinary
         *  element order.
         */
        const_iterator
            begin() const { return const_iterator (this->_M_impl._M_start); }

        /**
         *  Returns a read/write iterator that points one past the last
         *  element in the %vector.  Iteration is done in ordinary
         *  element order.
         */
        iterator
            end() { return iterator (this->_M_impl._M_finish); }

        /**
         *  Returns a read-only (constant) iterator that points one past
         *  the last element in the %vector.  Iteration is done in
         *  ordinary element order.
         */
        const_iterator
            end() const { return const_iterator (this->_M_impl._M_finish); }

        /**
         *  Returns a read/write reverse iterator that points to the
         *  last element in the %vector.  Iteration is done in reverse
         *  element order.
         */
        reverse_iterator
            rbegin() { return reverse_iterator(end()); }

        /**
         *  Returns a read-only (constant) reverse iterator that points
         *  to the last element in the %vector.  Iteration is done in
         *  reverse element order.
         */
        const_reverse_iterator
            rbegin() const { return const_reverse_iterator(end()); }

        /**
         *  Returns a read/write reverse iterator that points to one
         *  before the first element in the %vector.  Iteration is done
         *  in reverse element order.
         */
        reverse_iterator
            rend() { return reverse_iterator(begin()); }

        /**
         *  Returns a read-only (constant) reverse iterator that points
         *  to one before the first element in the %vector.  Iteration
         *  is done in reverse element order.
         */
        const_reverse_iterator
            rend() const { return const_reverse_iterator(begin()); }

        // [23.2.4.2] capacity
        /**  Returns the number of elements in the %vector.  */
        size_type
            size() const { return size_type(end() - begin()); }

        /**  Returns the size() of the largest possible %vector.  */
        size_type
            max_size() const { return size_type(-1) / sizeof(value_type); }

        /**
         *  @brief  Resizes the %vector to the specified number of elements.
         *  @param  new_size  Number of elements the %vector should contain.
         *  @param  x  Data with which new elements should be populated.
         *
         *  This function will %resize the %vector to the specified
         *  number of elements.  If the number is smaller than the
         *  %vector's current size the %vector is truncated, otherwise
         *  the %vector is extended and new elements are populated with
         *  given data.
         */
        void
            resize(size_type __new_size, const value_type& __x)
            {
                if (__new_size < size())
                    erase(begin() + __new_size, end());
                else
                    insert(end(), __new_size - size(), __x);
            }

        /**
         *  @brief  Resizes the %vector to the specified number of elements.
         *  @param  new_size  Number of elements the %vector should contain.
         *
         *  This function will resize the %vector to the specified
         *  number of elements.  If the number is smaller than the
         *  %vector's current size the %vector is truncated, otherwise
         *  the %vector is extended and new elements are
         *  default-constructed.
         */
        void
            resize(size_type __new_size) { resize(__new_size, value_type()); }

        /**
         *  Returns the total number of elements that the %vector can
         *  hold before needing to allocate more memory.
         */
        size_type
            capacity() const
            { return size_type(const_iterator(this->_M_impl._M_end_of_storage) - begin()); }

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

        /**
         *  @brief  Attempt to preallocate enough memory for specified number of
         *          elements.
         *  @param  n  Number of elements required.
         *  @throw  std::length_error  If @a n exceeds @c max_size().
         *
         *  This function attempts to reserve enough memory for the
         *  %vector to hold the specified number of elements.  If the
         *  number requested is more than max_size(), length_error is
         *  thrown.
         *
         *  The advantage of this function is that if optimal code is a
         *  necessity and the user can determine the number of elements
         *  that will be required, the user can reserve the memory in
         *  %advance, and thus prevent a possible reallocation of memory
         *  and copying of %vector data.
         */
        void
            reserve(size_type __n);

        // element access
        /**
         *  @brief  Subscript access to the data contained in the %vector.
         *  @param n The index of the element for which data should be
         *  accessed.
         *  @return  Read/write reference to data.
         *
         *  This operator allows for easy, array-style, data access.
         *  Note that data access with this operator is unchecked and
         *  out_of_range lookups are not defined. (For checked lookups
         *  see at().)
         */
        reference
            operator[](size_type __n) { return *(begin() + __n); }

        /**
         *  @brief  Subscript access to the data contained in the %vector.
         *  @param n The index of the element for which data should be
         *  accessed.
         *  @return  Read-only (constant) reference to data.
         *
         *  This operator allows for easy, array-style, data access.
         *  Note that data access with this operator is unchecked and
         *  out_of_range lookups are not defined. (For checked lookups
         *  see at().)
         */
        const_reference
            operator[](size_type __n) const { return *(begin() + __n); }

        protected:
        /// @if maint Safety check used only from at().  @endif
        void
            _M_range_check(size_type __n) const
            {
                if (__n >= this->size())
                    __throw_out_of_range(__N("vector::_M_range_check"));
            }

        public:
        /**
         *  @brief  Provides access to the data contained in the %vector.
         *  @param n The index of the element for which data should be
         *  accessed.
         *  @return  Read/write reference to data.
         *  @throw  std::out_of_range  If @a n is an invalid index.
         *
         *  This function provides for safer data access.  The parameter
         *  is first checked that it is in the range of the vector.  The
         *  function throws out_of_range if the check fails.
         */
        reference
            at(size_type __n) { _M_range_check(__n); return (*this)[__n]; }

        /**
         *  @brief  Provides access to the data contained in the %vector.
         *  @param n The index of the element for which data should be
         *  accessed.
         *  @return  Read-only (constant) reference to data.
         *  @throw  std::out_of_range  If @a n is an invalid index.
         *
         *  This function provides for safer data access.  The parameter
         *  is first checked that it is in the range of the vector.  The
         *  function throws out_of_range if the check fails.
         */
        const_reference
            at(size_type __n) const { _M_range_check(__n); return (*this)[__n]; }

        /**
         *  Returns a read/write reference to the data at the first
         *  element of the %vector.
         */
        reference
            front() { return *begin(); }

        /**
         *  Returns a read-only (constant) reference to the data at the first
         *  element of the %vector.
         */
        const_reference
            front() const { return *begin(); }

        /**
         *  Returns a read/write reference to the data at the last
         *  element of the %vector.
         */
        reference
            back() { return *(end() - 1); }

        /**
         *  Returns a read-only (constant) reference to the data at the
         *  last element of the %vector.
         */
        const_reference
            back() const { return *(end() - 1); }

        // [23.2.4.3] modifiers
        /**
         *  @brief  Add data to the end of the %vector.
         *  @param  x  Data to be added.
         *
         *  This is a typical stack operation.  The function creates an
         *  element at the end of the %vector and assigns the given data
         *  to it.  Due to the nature of a %vector this operation can be
         *  done in constant time if the %vector has preallocated space
         *  available.
         */
        void
            push_back(const value_type& __x)
            {
                if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage)
                {
                    std::_Construct(this->_M_impl._M_finish, __x);
                    ++this->_M_impl._M_finish;
                }
                else
                    _M_insert_aux(end(), __x);
            }

        /**
         *  @brief  Removes last element.
         *
         *  This is a typical stack operation. It shrinks the %vector by one.
         *
         *  Note that no data is returned, and if the last element's
         *  data is needed, it should be retrieved before pop_back() is
         *  called.
         */
        void
            pop_back()
            {
                --this->_M_impl._M_finish;
                std::_Destroy(this->_M_impl._M_finish);
            }

        /**
         *  @brief  Inserts given value into %vector before specified iterator.
         *  @param  position  An iterator into the %vector.
         *  @param  x  Data to be inserted.
         *  @return  An iterator that points to the inserted data.
         *
         *  This function will insert a copy of the given value before
         *  the specified location.  Note that this kind of operation
         *  could be expensive for a %vector and if it is frequently
         *  used the user should consider using std::list.
         */
        iterator
            insert(iterator __position, const value_type& __x);

        /**
         *  @brief  Inserts a number of copies of given data into the %vector.
         *  @param  position  An iterator into the %vector.
         *  @param  n  Number of elements to be inserted.
         *  @param  x  Data to be inserted.
         *
         *  This function will insert a specified number of copies of
         *  the given data before the location specified by @a position.
         *
         *  Note that this kind of operation could be expensive for a
         *  %vector and if it is frequently used the user should
         *  consider using std::list.
         */
        void
            insert(iterator __position, size_type __n, const value_type& __x)
            { _M_fill_insert(__position, __n, __x); }

        /**
         *  @brief  Inserts a range into the %vector.
         *  @param  position  An iterator into the %vector.
         *  @param  first  An input iterator.
         *  @param  last   An input iterator.
         *
         *  This function will insert copies of the data in the range
         *  [first,last) into the %vector before the location specified
         *  by @a pos.