basic_string.h

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

                    {
                        if (!_M_rep()->_M_is_leaked())
                            _M_leak_hard();
                    }

                size_type
                    _M_check(size_type __pos, const char* __s) const
                    {
                        if (__pos > this->size())
                            __throw_out_of_range(__N(__s));
                        return __pos;
                    }

                // NB: _M_limit doesn't check for a bad __pos value.
                size_type
                    _M_limit(size_type __pos, size_type __off) const
                    {
                        const bool __testoff =  __off < this->size() - __pos;
                        return __testoff ? __off : this->size() - __pos;
                    }

                // _S_copy_chars is a separate template to permit specialization
                // to optimize for the common case of pointers as iterators.
                template<class _Iterator>
                    static void
                    _S_copy_chars(_CharT* __p, _Iterator __k1, _Iterator __k2)
                    {
                        for (; __k1 != __k2; ++__k1, ++__p)
                            traits_type::assign(*__p, *__k1); // These types are off.
                    }

                static void
                    _S_copy_chars(_CharT* __p, iterator __k1, iterator __k2)
                    { _S_copy_chars(__p, __k1.base(), __k2.base()); }

                static void
                    _S_copy_chars(_CharT* __p, const_iterator __k1, const_iterator __k2)
                    { _S_copy_chars(__p, __k1.base(), __k2.base()); }

                static void
                    _S_copy_chars(_CharT* __p, _CharT* __k1, _CharT* __k2)
                    { traits_type::copy(__p, __k1, __k2 - __k1); }

                static void
                    _S_copy_chars(_CharT* __p, const _CharT* __k1, const _CharT* __k2)
                    { traits_type::copy(__p, __k1, __k2 - __k1); }

                void
                    _M_mutate(size_type __pos, size_type __len1, size_type __len2);

                void
                    _M_leak_hard();

                static _Rep&
                    _S_empty_rep()
                    { return _Rep::_S_empty_rep(); }

            public:
                // Construct/copy/destroy:
                // NB: We overload ctors in some cases instead of using default
                // arguments, per 17.4.4.4 para. 2 item 2.

                /**
                 *  @brief  Default constructor creates an empty string.
                 */
                inline
                    basic_string();

                /**
                 *  @brief  Construct an empty string using allocator a.
                 */
                explicit
                    basic_string(const _Alloc& __a);

                // NB: per LWG issue 42, semantics different from IS:
                /**
                 *  @brief  Construct string with copy of value of @a str.
                 *  @param  str  Source string.
                 */
                basic_string(const basic_string& __str);
                /**
                 *  @brief  Construct string as copy of a substring.
                 *  @param  str  Source string.
                 *  @param  pos  Index of first character to copy from.
                 *  @param  n  Number of characters to copy (default remainder).
                 */
                basic_string(const basic_string& __str, size_type __pos,
                        size_type __n = npos);
                /**
                 *  @brief  Construct string as copy of a substring.
                 *  @param  str  Source string.
                 *  @param  pos  Index of first character to copy from.
                 *  @param  n  Number of characters to copy.
                 *  @param  a  Allocator to use.
                 */
                basic_string(const basic_string& __str, size_type __pos,
                        size_type __n, const _Alloc& __a);

                /**
                 *  @brief  Construct string initialized by a character array.
                 *  @param  s  Source character array.
                 *  @param  n  Number of characters to copy.
                 *  @param  a  Allocator to use (default is default allocator).
                 *
                 *  NB: s must have at least n characters, '\0' has no special
                 *  meaning.
                 */
                basic_string(const _CharT* __s, size_type __n,
                        const _Alloc& __a = _Alloc());
                /**
                 *  @brief  Construct string as copy of a C string.
                 *  @param  s  Source C string.
                 *  @param  a  Allocator to use (default is default allocator).
                 */
                basic_string(const _CharT* __s, const _Alloc& __a = _Alloc());
                /**
                 *  @brief  Construct string as multiple characters.
                 *  @param  n  Number of characters.
                 *  @param  c  Character to use.
                 *  @param  a  Allocator to use (default is default allocator).
                 */
                basic_string(size_type __n, _CharT __c, const _Alloc& __a = _Alloc());

                /**
                 *  @brief  Construct string as copy of a range.
                 *  @param  beg  Start of range.
                 *  @param  end  End of range.
                 *  @param  a  Allocator to use (default is default allocator).
                 */
                template<class _InputIterator>
                    basic_string(_InputIterator __beg, _InputIterator __end,
                            const _Alloc& __a = _Alloc());

                /**
                 *  @brief  Destroy the string instance.
                 */
                ~basic_string()
                { _M_rep()->_M_dispose(this->get_allocator()); }

                /**
                 *  @brief  Assign the value of @a str to this string.
                 *  @param  str  Source string.
                 */
                basic_string&
                    operator=(const basic_string& __str) 
                    { 
                        this->assign(__str); 
                        return *this;
                    }

                /**
                 *  @brief  Copy contents of @a s into this string.
                 *  @param  s  Source null-terminated string.
                 */
                basic_string&
                    operator=(const _CharT* __s) 
                    { 
                        this->assign(__s); 
                        return *this;
                    }

                /**
                 *  @brief  Set value to string of length 1.
                 *  @param  c  Source character.
                 *
                 *  Assigning to a character makes this string length 1 and
                 *  (*this)[0] == @a c.
                 */
                basic_string&
                    operator=(_CharT __c) 
                    { 
                        this->assign(1, __c); 
                        return *this;
                    }

                // Iterators:
                /**
                 *  Returns a read/write iterator that points to the first character in
                 *  the %string.  Unshares the string.
                 */
                iterator
                    begin()
                    {
                        _M_leak();
                        return iterator(_M_data());
                    }

                /**
                 *  Returns a read-only (constant) iterator that points to the first
                 *  character in the %string.
                 */
                const_iterator
                    begin() const
                    { return const_iterator(_M_data()); }

                /**
                 *  Returns a read/write iterator that points one past the last
                 *  character in the %string.  Unshares the string.
                 */
                iterator
                    end()
                    {
                        _M_leak();
                        return iterator(_M_data() + this->size());
                    }

                /**
                 *  Returns a read-only (constant) iterator that points one past the
                 *  last character in the %string.
                 */
                const_iterator
                    end() const
                    { return const_iterator(_M_data() + this->size()); }

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

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

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

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

            public:
                // Capacity:
                ///  Returns the number of characters in the string, not including any
                ///  null-termination.
                size_type
                    size() const { return _M_rep()->_M_length; }

                ///  Returns the number of characters in the string, not including any
                ///  null-termination.
                size_type
                    length() const { return _M_rep()->_M_length; }

                /// Returns the size() of the largest possible %string.
                size_type
                    max_size() const { return _Rep::_S_max_size; }

                /**
                 *  @brief  Resizes the %string to the specified number of characters.
                 *  @param  n  Number of characters the %string should contain.
                 *  @param  c  Character to fill any new elements.
                 *
                 *  This function will %resize the %string to the specified
                 *  number of characters.  If the number is smaller than the
                 *  %string's current size the %string is truncated, otherwise
                 *  the %string is extended and new elements are set to @a c.
                 */