bastring.h
资源名称:Vc_STL.rar [点击查看]
上传用户:sichengcw
上传日期:2009-02-17
资源大小:202k
文件大小:21k
源码类别:
STL
开发平台:
Visual C++
- // Main templates for the -*- C++ -*- string classes.
- // Copyright (C) 1994, 1995 Free Software Foundation
- // This file is part of the GNU ANSI C++ Library. This library is free
- // software; you can redistribute it and/or modify it under the
- // terms of the GNU General Public License as published by the
- // Free Software Foundation; either version 2, or (at your option)
- // any later version.
- // This library is distributed in the hope that it will be useful,
- // but WITHOUT ANY WARRANTY; without even the implied warranty of
- // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- // GNU General Public License for more details.
- // You should have received a copy of the GNU General Public License
- // along with this library; see the file COPYING. If not, write to the Free
- // Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
- // As a special exception, if you link this library with files
- // compiled with a GNU compiler to produce an executable, this does not cause
- // the resulting executable to be covered by the GNU General Public License.
- // This exception does not however invalidate any other reasons why
- // the executable file might be covered by the GNU General Public License.
- // Written by Jason Merrill based upon the specification by Takanori Adachi
- // in ANSI X3J16/94-0013R2.
- #ifndef __BASTRING__
- #define __BASTRING__
- #ifdef __GNUG__
- #pragma interface
- #endif
- #include <cstddef>
- #include <std/straits.h>
- // NOTE : This does NOT conform to the draft standard and is likely to change
- #include <alloc.h>
- extern "C++" {
- class istream; class ostream;
- #include <iterator>
- #ifdef __STL_USE_EXCEPTIONS
- extern void __out_of_range (const char *);
- extern void __length_error (const char *);
- #define OUTOFRANGE(cond)
- do { if (cond) __out_of_range (#cond); } while (0)
- #define LENGTHERROR(cond)
- do { if (cond) __length_error (#cond); } while (0)
- #else
- #include <cassert>
- #define OUTOFRANGE(cond) assert (!(cond))
- #define LENGTHERROR(cond) assert (!(cond))
- #endif
- template <class charT, class traits = string_char_traits<charT>,
- class Allocator = alloc >
- class basic_string
- {
- private:
- struct Rep {
- size_t len, res, ref;
- bool selfish;
- charT* data () { return reinterpret_cast<charT *>(this + 1); }
- charT& operator[] (size_t s) { return data () [s]; }
- charT* grab () { if (selfish) return clone (); ++ref; return data (); }
- void release () { if (--ref == 0) delete this; }
- inline static void * operator new (size_t, size_t);
- inline static void operator delete (void *);
- inline static Rep* create (size_t);
- charT* clone ();
- inline void copy (size_t, const charT *, size_t);
- inline void move (size_t, const charT *, size_t);
- inline void set (size_t, const charT, size_t);
- inline static bool excess_slop (size_t, size_t);
- inline static size_t frob_size (size_t);
- private:
- Rep &operator= (const Rep &);
- };
- public:
- // types:
- typedef traits traits_type;
- typedef typename traits::char_type value_type;
- typedef Allocator allocator_type;
- typedef size_t size_type;
- typedef ptrdiff_t difference_type;
- typedef charT& reference;
- typedef const charT& const_reference;
- typedef charT* pointer;
- typedef const charT* const_pointer;
- typedef pointer iterator;
- typedef const_pointer const_iterator;
- typedef ::reverse_iterator<iterator> reverse_iterator;
- typedef ::reverse_iterator<const_iterator> const_reverse_iterator;
- static const size_type npos = static_cast<size_type>(-1);
- private:
- Rep *rep () const { return reinterpret_cast<Rep *>(dat) - 1; }
- void repup (Rep *p) { rep ()->release (); dat = p->data (); }
- public:
- const charT* data () const
- { return rep ()->data(); }
- size_type length () const
- { return rep ()->len; }
- size_type size () const
- { return rep ()->len; }
- size_type capacity () const
- { return rep ()->res; }
- size_type max_size () const
- { return (npos - 1)/sizeof (charT); } // XXX
- bool empty () const
- { return size () == 0; }
- // _lib.string.cons_ construct/copy/destroy:
- basic_string& operator= (const basic_string& str)
- {
- if (&str != this) { rep ()->release (); dat = str.rep ()->grab (); }
- return *this;
- }
- explicit basic_string (): dat (nilRep.grab ()) { }
- basic_string (const basic_string& str): dat (str.rep ()->grab ()) { }
- basic_string (const basic_string& str, size_type pos, size_type n = npos)
- : dat (nilRep.grab ()) { assign (str, pos, n); }
- basic_string (const charT* s, size_type n)
- : dat (nilRep.grab ()) { assign (s, n); }
- basic_string (const charT* s)
- : dat (nilRep.grab ()) { assign (s); }
- basic_string (size_type n, charT c)
- : dat (nilRep.grab ()) { assign (n, c); }
- #ifdef __STL_MEMBER_TEMPLATES
- template<class InputIterator>
- basic_string(InputIterator begin, InputIterator end)
- #else
- basic_string(const_iterator begin, const_iterator end)
- #endif
- : dat (nilRep.grab ()) { assign (begin, end); }
- ~basic_string ()
- { rep ()->release (); }
- void swap (basic_string &s) { charT *d = dat; dat = s.dat; s.dat = d; }
- basic_string& append (const basic_string& str, size_type pos = 0,
- size_type n = npos)
- { return replace (length (), 0, str, pos, n); }
- basic_string& append (const charT* s, size_type n)
- { return replace (length (), 0, s, n); }
- basic_string& append (const charT* s)
- { return append (s, traits::length (s)); }
- basic_string& append (size_type n, charT c)
- { return replace (length (), 0, n, c); }
- #ifdef __STL_MEMBER_TEMPLATES
- template<class InputIterator>
- basic_string& append(InputIterator first, InputIterator last)
- #else
- basic_string& append(const_iterator first, const_iterator last)
- #endif
- { return replace (iend (), iend (), first, last); }
- basic_string& assign (const basic_string& str, size_type pos = 0,
- size_type n = npos)
- { return replace (0, npos, str, pos, n); }
- basic_string& assign (const charT* s, size_type n)
- { return replace (0, npos, s, n); }
- basic_string& assign (const charT* s)
- { return assign (s, traits::length (s)); }
- basic_string& assign (size_type n, charT c)
- { return replace (0, npos, n, c); }
- #ifdef __STL_MEMBER_TEMPLATES
- template<class InputIterator>
- basic_string& assign(InputIterator first, InputIterator last)
- #else
- basic_string& assign(const_iterator first, const_iterator last)
- #endif
- { return replace (ibegin (), iend (), first, last); }
- basic_string& operator= (const charT* s)
- { return assign (s); }
- basic_string& operator= (charT c)
- { return assign (1, c); }
- basic_string& operator+= (const basic_string& rhs)
- { return append (rhs); }
- basic_string& operator+= (const charT* s)
- { return append (s); }
- basic_string& operator+= (charT c)
- { return append (1, c); }
- basic_string& insert (size_type pos1, const basic_string& str,
- size_type pos2 = 0, size_type n = npos)
- { return replace (pos1, 0, str, pos2, n); }
- basic_string& insert (size_type pos, const charT* s, size_type n)
- { return replace (pos, 0, s, n); }
- basic_string& insert (size_type pos, const charT* s)
- { return insert (pos, s, traits::length (s)); }
- basic_string& insert (size_type pos, size_type n, charT c)
- { return replace (pos, 0, n, c); }
- iterator insert(iterator p, charT c)
- { size_type __o = p - ibegin ();
- insert (p - ibegin (), 1, c); selfish ();
- return ibegin () + __o; }
- iterator insert(iterator p, size_type n, charT c)
- { size_type __o = p - ibegin ();
- insert (p - ibegin (), n, c); selfish ();
- return ibegin () + __o; }
- #ifdef __STL_MEMBER_TEMPLATES
- template<class InputIterator>
- void insert(iterator p, InputIterator first, InputIterator last)
- #else
- void insert(iterator p, const_iterator first, const_iterator last)
- #endif
- { replace (p, p, first, last); }
- basic_string& erase (size_type pos = 0, size_type n = npos)
- { return replace (pos, n, (size_type)0, (charT)0); }
- iterator erase(iterator p)
- { size_type __o = p - begin();
- replace (__o, 1, (size_type)0, (charT)0); selfish ();
- return ibegin() + __o; }
- iterator erase(iterator f, iterator l)
- { size_type __o = f - ibegin();
- replace (__o, l-f, (size_type)0, (charT)0);selfish ();
- return ibegin() + __o; }
- basic_string& replace (size_type pos1, size_type n1, const basic_string& str,
- size_type pos2 = 0, size_type n2 = npos);
- basic_string& replace (size_type pos, size_type n1, const charT* s,
- size_type n2);
- basic_string& replace (size_type pos, size_type n1, const charT* s)
- { return replace (pos, n1, s, traits::length (s)); }
- basic_string& replace (size_type pos, size_type n1, size_type n2, charT c);
- basic_string& replace (size_type pos, size_type n, charT c)
- { return replace (pos, n, 1, c); }
- basic_string& replace (iterator i1, iterator i2, const basic_string& str)
- { return replace (i1 - ibegin (), i2 - i1, str); }
- basic_string& replace (iterator i1, iterator i2, const charT* s, size_type n)
- { return replace (i1 - ibegin (), i2 - i1, s, n); }
- basic_string& replace (iterator i1, iterator i2, const charT* s)
- { return replace (i1 - ibegin (), i2 - i1, s); }
- basic_string& replace (iterator i1, iterator i2, size_type n, charT c)
- { return replace (i1 - ibegin (), i2 - i1, n, c); }
- #ifdef __STL_MEMBER_TEMPLATES
- template<class InputIterator>
- basic_string& replace(iterator i1, iterator i2,
- InputIterator j1, InputIterator j2);
- #else
- basic_string& replace(iterator i1, iterator i2,
- const_iterator j1, const_iterator j2);
- #endif
- private:
- static charT eos () { return traits::eos (); }
- void unique () { if (rep ()->ref > 1) alloc (length (), true); }
- void selfish () { unique (); rep ()->selfish = true; }
- public:
- charT operator[] (size_type pos) const
- {
- if (pos == length ())
- return eos ();
- return data ()[pos];
- }
- reference operator[] (size_type pos)
- { selfish (); return (*rep ())[pos]; }
- reference at (size_type pos)
- {
- OUTOFRANGE (pos >= length ());
- return (*this)[pos];
- }
- const_reference at (size_type pos) const
- {
- OUTOFRANGE (pos >= length ());
- return data ()[pos];
- }
- private:
- void terminate () const
- { traits::assign ((*rep ())[length ()], eos ()); }
- public:
- const charT* c_str () const
- { if (length () == 0) return ""; terminate (); return data (); }
- void resize (size_type n, charT c);
- void resize (size_type n)
- { resize (n, eos ()); }
- void reserve (size_type) { }
- size_type copy (charT* s, size_type n, size_type pos = 0) const;
- size_type find (const basic_string& str, size_type pos = 0) const
- { return find (str.data(), pos, str.length()); }
- size_type find (const charT* s, size_type pos, size_type n) const;
- size_type find (const charT* s, size_type pos = 0) const
- { return find (s, pos, traits::length (s)); }
- size_type find (charT c, size_type pos = 0) const;
- size_type rfind (const basic_string& str, size_type pos = npos) const
- { return rfind (str.data(), pos, str.length()); }
- size_type rfind (const charT* s, size_type pos, size_type n) const;
- size_type rfind (const charT* s, size_type pos = npos) const
- { return rfind (s, pos, traits::length (s)); }
- size_type rfind (charT c, size_type pos = npos) const;
- size_type find_first_of (const basic_string& str, size_type pos = 0) const
- { return find_first_of (str.data(), pos, str.length()); }
- size_type find_first_of (const charT* s, size_type pos, size_type n) const;
- size_type find_first_of (const charT* s, size_type pos = 0) const
- { return find_first_of (s, pos, traits::length (s)); }
- size_type find_first_of (charT c, size_type pos = 0) const
- { return find (c, pos); }
- size_type find_last_of (const basic_string& str, size_type pos = npos) const
- { return find_last_of (str.data(), pos, str.length()); }
- size_type find_last_of (const charT* s, size_type pos, size_type n) const;
- size_type find_last_of (const charT* s, size_type pos = npos) const
- { return find_last_of (s, pos, traits::length (s)); }
- size_type find_last_of (charT c, size_type pos = npos) const
- { return rfind (c, pos); }
- size_type find_first_not_of (const basic_string& str, size_type pos = 0) const
- { return find_first_not_of (str.data(), pos, str.length()); }
- size_type find_first_not_of (const charT* s, size_type pos, size_type n) const;
- size_type find_first_not_of (const charT* s, size_type pos = 0) const
- { return find_first_not_of (s, pos, traits::length (s)); }
- size_type find_first_not_of (charT c, size_type pos = 0) const;
- size_type find_last_not_of (const basic_string& str, size_type pos = npos) const
- { return find_last_not_of (str.data(), pos, str.length()); }
- size_type find_last_not_of (const charT* s, size_type pos, size_type n) const;
- size_type find_last_not_of (const charT* s, size_type pos = npos) const
- { return find_last_not_of (s, pos, traits::length (s)); }
- size_type find_last_not_of (charT c, size_type pos = npos) const;
- basic_string substr (size_type pos = 0, size_type n = npos) const
- { return basic_string (*this, pos, n); }
- int compare (const basic_string& str, size_type pos = 0, size_type n = npos) const;
- // There is no 'strncmp' equivalent for charT pointers.
- int compare (const charT* s, size_type pos, size_type n) const;
- int compare (const charT* s, size_type pos = 0) const
- { return compare (s, pos, traits::length (s)); }
- iterator begin () { selfish (); return &(*this)[0]; }
- iterator end () { selfish (); return &(*this)[length ()]; }
- private:
- iterator ibegin () const { return &(*rep ())[0]; }
- iterator iend () const { return &(*rep ())[length ()]; }
- public:
- const_iterator begin () const { return ibegin (); }
- const_iterator end () const { return iend (); }
- reverse_iterator rbegin() { return reverse_iterator (end ()); }
- const_reverse_iterator rbegin() const
- { return const_reverse_iterator (end ()); }
- reverse_iterator rend() { return reverse_iterator (begin ()); }
- const_reverse_iterator rend() const
- { return const_reverse_iterator (begin ()); }
- private:
- void alloc (size_type size, bool save);
- static size_type _find (const charT* ptr, charT c, size_type xpos, size_type len);
- inline bool check_realloc (size_type s) const;
- static Rep nilRep;
- charT *dat;
- };
- #ifdef __STL_MEMBER_TEMPLATES
- template <class charT, class traits, class Allocator> template <class InputIterator>
- basic_string <charT, traits, Allocator>& basic_string <charT, traits, Allocator>::
- replace (iterator i1, iterator i2, InputIterator j1, InputIterator j2)
- #else
- template <class charT, class traits, class Allocator>
- basic_string <charT, traits, Allocator>& basic_string <charT, traits, Allocator>::
- replace (iterator i1, iterator i2, const_iterator j1, const_iterator j2)
- #endif
- {
- const size_type len = length ();
- size_type pos = i1 - ibegin ();
- size_type n1 = i2 - i1;
- size_type n2 = j2 - j1;
- OUTOFRANGE (pos > len);
- if (n1 > len - pos)
- n1 = len - pos;
- LENGTHERROR (len - n1 > max_size () - n2);
- size_t newlen = len - n1 + n2;
- if (check_realloc (newlen))
- {
- Rep *p = Rep::create (newlen);
- p->copy (0, data (), pos);
- p->copy (pos + n2, data () + pos + n1, len - (pos + n1));
- for (; j1 != j2; ++j1, ++pos)
- traits::assign ((*p)[pos], *j1);
- repup (p);
- }
- else
- {
- rep ()->move (pos + n2, data () + pos + n1, len - (pos + n1));
- for (; j1 != j2; ++j1, ++pos)
- traits::assign ((*rep ())[pos], *j1);
- }
- rep ()->len = newlen;
- return *this;
- }
- template <class charT, class traits, class Allocator>
- inline basic_string <charT, traits, Allocator>
- operator+ (const basic_string <charT, traits, Allocator>& lhs,
- const basic_string <charT, traits, Allocator>& rhs)
- {
- basic_string <charT, traits, Allocator> str (lhs);
- str.append (rhs);
- return str;
- }
- template <class charT, class traits, class Allocator>
- inline basic_string <charT, traits, Allocator>
- operator+ (const charT* lhs, const basic_string <charT, traits, Allocator>& rhs)
- {
- basic_string <charT, traits, Allocator> str (lhs);
- str.append (rhs);
- return str;
- }
- template <class charT, class traits, class Allocator>
- inline basic_string <charT, traits, Allocator>
- operator+ (charT lhs, const basic_string <charT, traits, Allocator>& rhs)
- {
- basic_string <charT, traits, Allocator> str (1, lhs);
- str.append (rhs);
- return str;
- }
- template <class charT, class traits, class Allocator>
- inline basic_string <charT, traits, Allocator>
- operator+ (const basic_string <charT, traits, Allocator>& lhs, const charT* rhs)
- {
- basic_string <charT, traits, Allocator> str (lhs);
- str.append (rhs);
- return str;
- }
- template <class charT, class traits, class Allocator>
- inline basic_string <charT, traits, Allocator>
- operator+ (const basic_string <charT, traits, Allocator>& lhs, charT rhs)
- {
- basic_string <charT, traits, Allocator> str (lhs);
- str.append (1, rhs);
- return str;
- }
- template <class charT, class traits, class Allocator>
- inline bool
- operator== (const basic_string <charT, traits, Allocator>& lhs,
- const basic_string <charT, traits, Allocator>& rhs)
- {
- return (lhs.compare (rhs) == 0);
- }
- template <class charT, class traits, class Allocator>
- inline bool
- operator== (const charT* lhs, const basic_string <charT, traits, Allocator>& rhs)
- {
- return (rhs.compare (lhs) == 0);
- }
- template <class charT, class traits, class Allocator>
- inline bool
- operator== (const basic_string <charT, traits, Allocator>& lhs, const charT* rhs)
- {
- return (lhs.compare (rhs) == 0);
- }
- template <class charT, class traits, class Allocator>
- inline bool
- operator!= (const charT* lhs, const basic_string <charT, traits, Allocator>& rhs)
- {
- return (rhs.compare (lhs) != 0);
- }
- template <class charT, class traits, class Allocator>
- inline bool
- operator!= (const basic_string <charT, traits, Allocator>& lhs, const charT* rhs)
- {
- return (lhs.compare (rhs) != 0);
- }
- template <class charT, class traits, class Allocator>
- inline bool
- operator< (const basic_string <charT, traits, Allocator>& lhs,
- const basic_string <charT, traits, Allocator>& rhs)
- {
- return (lhs.compare (rhs) < 0);
- }
- template <class charT, class traits, class Allocator>
- inline bool
- operator< (const charT* lhs, const basic_string <charT, traits, Allocator>& rhs)
- {
- return (rhs.compare (lhs) > 0);
- }
- template <class charT, class traits, class Allocator>
- inline bool
- operator< (const basic_string <charT, traits, Allocator>& lhs, const charT* rhs)
- {
- return (lhs.compare (rhs) < 0);
- }
- template <class charT, class traits, class Allocator>
- inline bool
- operator> (const charT* lhs, const basic_string <charT, traits, Allocator>& rhs)
- {
- return (rhs.compare (lhs) < 0);
- }
- template <class charT, class traits, class Allocator>
- inline bool
- operator> (const basic_string <charT, traits, Allocator>& lhs, const charT* rhs)
- {
- return (lhs.compare (rhs) > 0);
- }
- template <class charT, class traits, class Allocator>
- inline bool
- operator<= (const charT* lhs, const basic_string <charT, traits, Allocator>& rhs)
- {
- return (rhs.compare (lhs) >= 0);
- }
- template <class charT, class traits, class Allocator>
- inline bool
- operator<= (const basic_string <charT, traits, Allocator>& lhs, const charT* rhs)
- {
- return (lhs.compare (rhs) <= 0);
- }
- template <class charT, class traits, class Allocator>
- inline bool
- operator>= (const charT* lhs, const basic_string <charT, traits, Allocator>& rhs)
- {
- return (rhs.compare (lhs) <= 0);
- }
- template <class charT, class traits, class Allocator>
- inline bool
- operator>= (const basic_string <charT, traits, Allocator>& lhs, const charT* rhs)
- {
- return (lhs.compare (rhs) >= 0);
- }
- template <class charT, class traits, class Allocator>
- inline bool
- operator!= (const basic_string <charT, traits, Allocator>& lhs,
- const basic_string <charT, traits, Allocator>& rhs)
- {
- return (lhs.compare (rhs) != 0);
- }
- template <class charT, class traits, class Allocator>
- inline bool
- operator> (const basic_string <charT, traits, Allocator>& lhs,
- const basic_string <charT, traits, Allocator>& rhs)
- {
- return (lhs.compare (rhs) > 0);
- }
- template <class charT, class traits, class Allocator>
- inline bool
- operator<= (const basic_string <charT, traits, Allocator>& lhs,
- const basic_string <charT, traits, Allocator>& rhs)
- {
- return (lhs.compare (rhs) <= 0);
- }
- template <class charT, class traits, class Allocator>
- inline bool
- operator>= (const basic_string <charT, traits, Allocator>& lhs,
- const basic_string <charT, traits, Allocator>& rhs)
- {
- return (lhs.compare (rhs) >= 0);
- }
- class istream; class ostream;
- template <class charT, class traits, class Allocator> istream&
- operator>> (istream&, basic_string <charT, traits, Allocator>&);
- template <class charT, class traits, class Allocator> ostream&
- operator<< (ostream&, const basic_string <charT, traits, Allocator>&);
- template <class charT, class traits, class Allocator> istream&
- getline (istream&, basic_string <charT, traits, Allocator>&, charT delim = 'n');
- } // extern "C++"
- #include <std/bastring.cc>
- #endif