bastring.h
上传用户:sichengcw
上传日期:2009-02-17
资源大小:202k
文件大小:21k
源码类别:

STL

开发平台:

Visual C++

  1. // Main templates for the -*- C++ -*- string classes.
  2. // Copyright (C) 1994, 1995 Free Software Foundation
  3. // This file is part of the GNU ANSI C++ Library.  This library is free
  4. // software; you can redistribute it and/or modify it under the
  5. // terms of the GNU General Public License as published by the
  6. // Free Software Foundation; either version 2, or (at your option)
  7. // any later version.
  8. // This library is distributed in the hope that it will be useful,
  9. // but WITHOUT ANY WARRANTY; without even the implied warranty of
  10. // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11. // GNU General Public License for more details.
  12. // You should have received a copy of the GNU General Public License
  13. // along with this library; see the file COPYING.  If not, write to the Free
  14. // Software Foundation, 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  15. // As a special exception, if you link this library with files
  16. // compiled with a GNU compiler to produce an executable, this does not cause
  17. // the resulting executable to be covered by the GNU General Public License.
  18. // This exception does not however invalidate any other reasons why
  19. // the executable file might be covered by the GNU General Public License.
  20. // Written by Jason Merrill based upon the specification by Takanori Adachi
  21. // in ANSI X3J16/94-0013R2.
  22. #ifndef __BASTRING__
  23. #define __BASTRING__
  24. #ifdef __GNUG__
  25. #pragma interface
  26. #endif
  27. #include <cstddef>
  28. #include <std/straits.h>
  29. // NOTE : This does NOT conform to the draft standard and is likely to change
  30. #include <alloc.h>
  31. extern "C++" {
  32. class istream; class ostream;
  33. #include <iterator>
  34. #ifdef __STL_USE_EXCEPTIONS
  35. extern void __out_of_range (const char *);
  36. extern void __length_error (const char *);
  37. #define OUTOFRANGE(cond) 
  38.   do { if (cond) __out_of_range (#cond); } while (0)
  39. #define LENGTHERROR(cond) 
  40.   do { if (cond) __length_error (#cond); } while (0)
  41. #else
  42. #include <cassert>
  43. #define OUTOFRANGE(cond) assert (!(cond))
  44. #define LENGTHERROR(cond) assert (!(cond))
  45. #endif
  46. template <class charT, class traits = string_char_traits<charT>,
  47.   class Allocator = alloc >
  48. class basic_string
  49. {
  50. private:
  51.   struct Rep {
  52.     size_t len, res, ref;
  53.     bool selfish;
  54.     charT* data () { return reinterpret_cast<charT *>(this + 1); }
  55.     charT& operator[] (size_t s) { return data () [s]; }
  56.     charT* grab () { if (selfish) return clone (); ++ref; return data (); }
  57.     void release () { if (--ref == 0) delete this; }
  58.     inline static void * operator new (size_t, size_t);
  59.     inline static void operator delete (void *);
  60.     inline static Rep* create (size_t);
  61.     charT* clone ();
  62.     inline void copy (size_t, const charT *, size_t);
  63.     inline void move (size_t, const charT *, size_t);
  64.     inline void set  (size_t, const charT,   size_t);
  65.     inline static bool excess_slop (size_t, size_t);
  66.     inline static size_t frob_size (size_t);
  67.   private:
  68.     Rep &operator= (const Rep &);
  69.   };
  70. public:
  71. // types:
  72.   typedef    traits traits_type;
  73.   typedef typename traits::char_type value_type;
  74.   typedef    Allocator allocator_type;
  75.   typedef size_t size_type;
  76.   typedef ptrdiff_t difference_type;
  77.   typedef charT& reference;
  78.   typedef const charT& const_reference;
  79.   typedef charT* pointer;
  80.   typedef const charT* const_pointer;
  81.   typedef pointer iterator;
  82.   typedef const_pointer const_iterator;
  83.   typedef ::reverse_iterator<iterator> reverse_iterator;
  84.   typedef ::reverse_iterator<const_iterator> const_reverse_iterator;
  85.   static const size_type npos = static_cast<size_type>(-1);
  86. private:
  87.   Rep *rep () const { return reinterpret_cast<Rep *>(dat) - 1; }
  88.   void repup (Rep *p) { rep ()->release (); dat = p->data (); }
  89. public:
  90.   const charT* data () const
  91.     { return rep ()->data(); }
  92.   size_type length () const
  93.     { return rep ()->len; }
  94.   size_type size () const
  95.     { return rep ()->len; }
  96.   size_type capacity () const
  97.     { return rep ()->res; }
  98.   size_type max_size () const
  99.     { return (npos - 1)/sizeof (charT); } // XXX
  100.   bool empty () const
  101.     { return size () == 0; }
  102. // _lib.string.cons_ construct/copy/destroy:
  103.   basic_string& operator= (const basic_string& str)
  104.     {
  105.       if (&str != this) { rep ()->release (); dat = str.rep ()->grab (); }
  106.       return *this;
  107.     }
  108.   explicit basic_string (): dat (nilRep.grab ()) { }
  109.   basic_string (const basic_string& str): dat (str.rep ()->grab ()) { }
  110.   basic_string (const basic_string& str, size_type pos, size_type n = npos)
  111.     : dat (nilRep.grab ()) { assign (str, pos, n); }
  112.   basic_string (const charT* s, size_type n)
  113.     : dat (nilRep.grab ()) { assign (s, n); }
  114.   basic_string (const charT* s)
  115.     : dat (nilRep.grab ()) { assign (s); }
  116.   basic_string (size_type n, charT c)
  117.     : dat (nilRep.grab ()) { assign (n, c); }
  118. #ifdef __STL_MEMBER_TEMPLATES
  119.   template<class InputIterator>
  120.     basic_string(InputIterator begin, InputIterator end)
  121. #else
  122.   basic_string(const_iterator begin, const_iterator end)
  123. #endif
  124.     : dat (nilRep.grab ()) { assign (begin, end); }
  125.   ~basic_string ()
  126.     { rep ()->release (); }
  127.   void swap (basic_string &s) { charT *d = dat; dat = s.dat; s.dat = d; }
  128.   basic_string& append (const basic_string& str, size_type pos = 0,
  129. size_type n = npos)
  130.     { return replace (length (), 0, str, pos, n); }
  131.   basic_string& append (const charT* s, size_type n)
  132.     { return replace (length (), 0, s, n); }
  133.   basic_string& append (const charT* s)
  134.     { return append (s, traits::length (s)); }
  135.   basic_string& append (size_type n, charT c)
  136.     { return replace (length (), 0, n, c); }
  137. #ifdef __STL_MEMBER_TEMPLATES
  138.   template<class InputIterator>
  139.     basic_string& append(InputIterator first, InputIterator last)
  140. #else
  141.   basic_string& append(const_iterator first, const_iterator last)
  142. #endif
  143.     { return replace (iend (), iend (), first, last); }
  144.   basic_string& assign (const basic_string& str, size_type pos = 0,
  145. size_type n = npos)
  146.     { return replace (0, npos, str, pos, n); }
  147.   basic_string& assign (const charT* s, size_type n)
  148.     { return replace (0, npos, s, n); }
  149.   basic_string& assign (const charT* s)
  150.     { return assign (s, traits::length (s)); }
  151.   basic_string& assign (size_type n, charT c)
  152.     { return replace (0, npos, n, c); }
  153. #ifdef __STL_MEMBER_TEMPLATES
  154.   template<class InputIterator>
  155.     basic_string& assign(InputIterator first, InputIterator last)
  156. #else
  157.   basic_string& assign(const_iterator first, const_iterator last)
  158. #endif
  159.     { return replace (ibegin (), iend (), first, last); }
  160.   basic_string& operator= (const charT* s)
  161.     { return assign (s); }
  162.   basic_string& operator= (charT c)
  163.     { return assign (1, c); }
  164.   basic_string& operator+= (const basic_string& rhs)
  165.     { return append (rhs); }
  166.   basic_string& operator+= (const charT* s)
  167.     { return append (s); }
  168.   basic_string& operator+= (charT c)
  169.     { return append (1, c); }
  170.   basic_string& insert (size_type pos1, const basic_string& str,
  171. size_type pos2 = 0, size_type n = npos)
  172.     { return replace (pos1, 0, str, pos2, n); }
  173.   basic_string& insert (size_type pos, const charT* s, size_type n)
  174.     { return replace (pos, 0, s, n); }
  175.   basic_string& insert (size_type pos, const charT* s)
  176.     { return insert (pos, s, traits::length (s)); }
  177.   basic_string& insert (size_type pos, size_type n, charT c)
  178.     { return replace (pos, 0, n, c); }
  179.   iterator insert(iterator p, charT c)
  180.     { size_type __o = p - ibegin ();
  181.       insert (p - ibegin (), 1, c); selfish ();
  182.       return ibegin () + __o; }
  183.   iterator insert(iterator p, size_type n, charT c)
  184.     { size_type __o = p - ibegin ();
  185.       insert (p - ibegin (), n, c); selfish ();
  186.       return ibegin () + __o; }
  187. #ifdef __STL_MEMBER_TEMPLATES
  188.   template<class InputIterator>
  189.     void insert(iterator p, InputIterator first, InputIterator last)
  190. #else
  191.   void insert(iterator p, const_iterator first, const_iterator last)
  192. #endif
  193.     { replace (p, p, first, last); }
  194.   basic_string& erase (size_type pos = 0, size_type n = npos)
  195.     { return replace (pos, n, (size_type)0, (charT)0); }
  196.   iterator erase(iterator p)
  197.     { size_type __o = p - begin();
  198.       replace (__o, 1, (size_type)0, (charT)0); selfish ();
  199.       return ibegin() + __o; }
  200.   iterator erase(iterator f, iterator l)
  201.     { size_type __o = f - ibegin();
  202.       replace (__o, l-f, (size_type)0, (charT)0);selfish ();
  203.       return ibegin() + __o; }
  204.   basic_string& replace (size_type pos1, size_type n1, const basic_string& str,
  205.  size_type pos2 = 0, size_type n2 = npos);
  206.   basic_string& replace (size_type pos, size_type n1, const charT* s,
  207.  size_type n2);
  208.   basic_string& replace (size_type pos, size_type n1, const charT* s)
  209.     { return replace (pos, n1, s, traits::length (s)); }
  210.   basic_string& replace (size_type pos, size_type n1, size_type n2, charT c);
  211.   basic_string& replace (size_type pos, size_type n, charT c)
  212.     { return replace (pos, n, 1, c); }
  213.   basic_string& replace (iterator i1, iterator i2, const basic_string& str)
  214.     { return replace (i1 - ibegin (), i2 - i1, str); }
  215.   basic_string& replace (iterator i1, iterator i2, const charT* s, size_type n)
  216.     { return replace (i1 - ibegin (), i2 - i1, s, n); }
  217.   basic_string& replace (iterator i1, iterator i2, const charT* s)
  218.     { return replace (i1 - ibegin (), i2 - i1, s); }
  219.   basic_string& replace (iterator i1, iterator i2, size_type n, charT c)
  220.     { return replace (i1 - ibegin (), i2 - i1, n, c); }
  221. #ifdef __STL_MEMBER_TEMPLATES
  222.   template<class InputIterator>
  223.     basic_string& replace(iterator i1, iterator i2,
  224.   InputIterator j1, InputIterator j2);
  225. #else
  226.   basic_string& replace(iterator i1, iterator i2,
  227. const_iterator j1, const_iterator j2);
  228. #endif
  229. private:
  230.   static charT eos () { return traits::eos (); }
  231.   void unique () { if (rep ()->ref > 1) alloc (length (), true); }
  232.   void selfish () { unique (); rep ()->selfish = true; }
  233. public:
  234.   charT operator[] (size_type pos) const
  235.     {
  236.       if (pos == length ())
  237. return eos ();
  238.       return data ()[pos];
  239.     }
  240.   reference operator[] (size_type pos)
  241.     { selfish (); return (*rep ())[pos]; }
  242.   reference at (size_type pos)
  243.     {
  244.       OUTOFRANGE (pos >= length ());
  245.       return (*this)[pos];
  246.     }
  247.   const_reference at (size_type pos) const
  248.     {
  249.       OUTOFRANGE (pos >= length ());
  250.       return data ()[pos];
  251.     }
  252. private:
  253.   void terminate () const
  254.     { traits::assign ((*rep ())[length ()], eos ()); }
  255. public:
  256.   const charT* c_str () const
  257.     { if (length () == 0) return ""; terminate (); return data (); }
  258.   void resize (size_type n, charT c);
  259.   void resize (size_type n)
  260.     { resize (n, eos ()); }
  261.   void reserve (size_type) { }
  262.   size_type copy (charT* s, size_type n, size_type pos = 0) const;
  263.   size_type find (const basic_string& str, size_type pos = 0) const
  264.     { return find (str.data(), pos, str.length()); }
  265.   size_type find (const charT* s, size_type pos, size_type n) const;
  266.   size_type find (const charT* s, size_type pos = 0) const
  267.     { return find (s, pos, traits::length (s)); }
  268.   size_type find (charT c, size_type pos = 0) const;
  269.   size_type rfind (const basic_string& str, size_type pos = npos) const
  270.     { return rfind (str.data(), pos, str.length()); }
  271.   size_type rfind (const charT* s, size_type pos, size_type n) const;
  272.   size_type rfind (const charT* s, size_type pos = npos) const
  273.     { return rfind (s, pos, traits::length (s)); }
  274.   size_type rfind (charT c, size_type pos = npos) const;
  275.   size_type find_first_of (const basic_string& str, size_type pos = 0) const
  276.     { return find_first_of (str.data(), pos, str.length()); }
  277.   size_type find_first_of (const charT* s, size_type pos, size_type n) const;
  278.   size_type find_first_of (const charT* s, size_type pos = 0) const
  279.     { return find_first_of (s, pos, traits::length (s)); }
  280.   size_type find_first_of (charT c, size_type pos = 0) const
  281.     { return find (c, pos); }
  282.   size_type find_last_of (const basic_string& str, size_type pos = npos) const
  283.     { return find_last_of (str.data(), pos, str.length()); }
  284.   size_type find_last_of (const charT* s, size_type pos, size_type n) const;
  285.   size_type find_last_of (const charT* s, size_type pos = npos) const
  286.     { return find_last_of (s, pos, traits::length (s)); }
  287.   size_type find_last_of (charT c, size_type pos = npos) const
  288.     { return rfind (c, pos); }
  289.   size_type find_first_not_of (const basic_string& str, size_type pos = 0) const
  290.     { return find_first_not_of (str.data(), pos, str.length()); }
  291.   size_type find_first_not_of (const charT* s, size_type pos, size_type n) const;
  292.   size_type find_first_not_of (const charT* s, size_type pos = 0) const
  293.     { return find_first_not_of (s, pos, traits::length (s)); }
  294.   size_type find_first_not_of (charT c, size_type pos = 0) const;
  295.   size_type find_last_not_of (const basic_string& str, size_type pos = npos) const
  296.     { return find_last_not_of (str.data(), pos, str.length()); }
  297.   size_type find_last_not_of (const charT* s, size_type pos, size_type n) const;
  298.   size_type find_last_not_of (const charT* s, size_type pos = npos) const
  299.     { return find_last_not_of (s, pos, traits::length (s)); }
  300.   size_type find_last_not_of (charT c, size_type pos = npos) const;
  301.   basic_string substr (size_type pos = 0, size_type n = npos) const
  302.     { return basic_string (*this, pos, n); }
  303.   int compare (const basic_string& str, size_type pos = 0, size_type n = npos) const;
  304.   // There is no 'strncmp' equivalent for charT pointers.
  305.   int compare (const charT* s, size_type pos, size_type n) const;
  306.   int compare (const charT* s, size_type pos = 0) const
  307.     { return compare (s, pos, traits::length (s)); }
  308.   iterator begin () { selfish (); return &(*this)[0]; }
  309.   iterator end () { selfish (); return &(*this)[length ()]; }
  310. private:
  311.   iterator ibegin () const { return &(*rep ())[0]; }
  312.   iterator iend () const { return &(*rep ())[length ()]; }
  313. public:
  314.   const_iterator begin () const { return ibegin (); }
  315.   const_iterator end () const { return iend (); }
  316.   reverse_iterator       rbegin() { return reverse_iterator (end ()); }
  317.   const_reverse_iterator rbegin() const
  318.     { return const_reverse_iterator (end ()); }
  319.   reverse_iterator       rend() { return reverse_iterator (begin ()); }
  320.   const_reverse_iterator rend() const
  321.     { return const_reverse_iterator (begin ()); }
  322. private:
  323.   void alloc (size_type size, bool save);
  324.   static size_type _find (const charT* ptr, charT c, size_type xpos, size_type len);
  325.   inline bool check_realloc (size_type s) const;
  326.   static Rep nilRep;
  327.   charT *dat;
  328. };
  329. #ifdef __STL_MEMBER_TEMPLATES
  330. template <class charT, class traits, class Allocator> template <class InputIterator>
  331. basic_string <charT, traits, Allocator>& basic_string <charT, traits, Allocator>::
  332. replace (iterator i1, iterator i2, InputIterator j1, InputIterator j2)
  333. #else
  334. template <class charT, class traits, class Allocator>
  335. basic_string <charT, traits, Allocator>& basic_string <charT, traits, Allocator>::
  336. replace (iterator i1, iterator i2, const_iterator j1, const_iterator j2)
  337. #endif
  338. {
  339.   const size_type len = length ();
  340.   size_type pos = i1 - ibegin ();
  341.   size_type n1 = i2 - i1;
  342.   size_type n2 = j2 - j1;
  343.   OUTOFRANGE (pos > len);
  344.   if (n1 > len - pos)
  345.     n1 = len - pos;
  346.   LENGTHERROR (len - n1 > max_size () - n2);
  347.   size_t newlen = len - n1 + n2;
  348.   if (check_realloc (newlen))
  349.     {
  350.       Rep *p = Rep::create (newlen);
  351.       p->copy (0, data (), pos);
  352.       p->copy (pos + n2, data () + pos + n1, len - (pos + n1));
  353.       for (; j1 != j2; ++j1, ++pos)
  354. traits::assign ((*p)[pos], *j1);
  355.       repup (p);
  356.     }
  357.   else
  358.     {
  359.       rep ()->move (pos + n2, data () + pos + n1, len - (pos + n1));
  360.       for (; j1 != j2; ++j1, ++pos)
  361. traits::assign ((*rep ())[pos], *j1);
  362.     }
  363.   rep ()->len = newlen;
  364.   return *this;
  365. }
  366. template <class charT, class traits, class Allocator>
  367. inline basic_string <charT, traits, Allocator>
  368. operator+ (const basic_string <charT, traits, Allocator>& lhs,
  369.    const basic_string <charT, traits, Allocator>& rhs)
  370. {
  371.   basic_string <charT, traits, Allocator> str (lhs);
  372.   str.append (rhs);
  373.   return str;
  374. }
  375. template <class charT, class traits, class Allocator>
  376. inline basic_string <charT, traits, Allocator>
  377. operator+ (const charT* lhs, const basic_string <charT, traits, Allocator>& rhs)
  378. {
  379.   basic_string <charT, traits, Allocator> str (lhs);
  380.   str.append (rhs);
  381.   return str;
  382. }
  383. template <class charT, class traits, class Allocator>
  384. inline basic_string <charT, traits, Allocator>
  385. operator+ (charT lhs, const basic_string <charT, traits, Allocator>& rhs)
  386. {
  387.   basic_string <charT, traits, Allocator> str (1, lhs);
  388.   str.append (rhs);
  389.   return str;
  390. }
  391. template <class charT, class traits, class Allocator>
  392. inline basic_string <charT, traits, Allocator>
  393. operator+ (const basic_string <charT, traits, Allocator>& lhs, const charT* rhs)
  394. {
  395.   basic_string <charT, traits, Allocator> str (lhs);
  396.   str.append (rhs);
  397.   return str;
  398. }
  399. template <class charT, class traits, class Allocator>
  400. inline basic_string <charT, traits, Allocator>
  401. operator+ (const basic_string <charT, traits, Allocator>& lhs, charT rhs)
  402. {
  403.   basic_string <charT, traits, Allocator> str (lhs);
  404.   str.append (1, rhs);
  405.   return str;
  406. }
  407. template <class charT, class traits, class Allocator>
  408. inline bool
  409. operator== (const basic_string <charT, traits, Allocator>& lhs,
  410.     const basic_string <charT, traits, Allocator>& rhs)
  411. {
  412.   return (lhs.compare (rhs) == 0);
  413. }
  414. template <class charT, class traits, class Allocator>
  415. inline bool
  416. operator== (const charT* lhs, const basic_string <charT, traits, Allocator>& rhs)
  417. {
  418.   return (rhs.compare (lhs) == 0);
  419. }
  420. template <class charT, class traits, class Allocator>
  421. inline bool
  422. operator== (const basic_string <charT, traits, Allocator>& lhs, const charT* rhs)
  423. {
  424.   return (lhs.compare (rhs) == 0);
  425. }
  426. template <class charT, class traits, class Allocator>
  427. inline bool
  428. operator!= (const charT* lhs, const basic_string <charT, traits, Allocator>& rhs)
  429. {
  430.   return (rhs.compare (lhs) != 0);
  431. }
  432. template <class charT, class traits, class Allocator>
  433. inline bool
  434. operator!= (const basic_string <charT, traits, Allocator>& lhs, const charT* rhs)
  435. {
  436.   return (lhs.compare (rhs) != 0);
  437. }
  438. template <class charT, class traits, class Allocator>
  439. inline bool
  440. operator< (const basic_string <charT, traits, Allocator>& lhs,
  441.     const basic_string <charT, traits, Allocator>& rhs)
  442. {
  443.   return (lhs.compare (rhs) < 0);
  444. }
  445. template <class charT, class traits, class Allocator>
  446. inline bool
  447. operator< (const charT* lhs, const basic_string <charT, traits, Allocator>& rhs)
  448. {
  449.   return (rhs.compare (lhs) > 0);
  450. }
  451. template <class charT, class traits, class Allocator>
  452. inline bool
  453. operator< (const basic_string <charT, traits, Allocator>& lhs, const charT* rhs)
  454. {
  455.   return (lhs.compare (rhs) < 0);
  456. }
  457. template <class charT, class traits, class Allocator>
  458. inline bool
  459. operator> (const charT* lhs, const basic_string <charT, traits, Allocator>& rhs)
  460. {
  461.   return (rhs.compare (lhs) < 0);
  462. }
  463. template <class charT, class traits, class Allocator>
  464. inline bool
  465. operator> (const basic_string <charT, traits, Allocator>& lhs, const charT* rhs)
  466. {
  467.   return (lhs.compare (rhs) > 0);
  468. }
  469. template <class charT, class traits, class Allocator>
  470. inline bool
  471. operator<= (const charT* lhs, const basic_string <charT, traits, Allocator>& rhs)
  472. {
  473.   return (rhs.compare (lhs) >= 0);
  474. }
  475. template <class charT, class traits, class Allocator>
  476. inline bool
  477. operator<= (const basic_string <charT, traits, Allocator>& lhs, const charT* rhs)
  478. {
  479.   return (lhs.compare (rhs) <= 0);
  480. }
  481. template <class charT, class traits, class Allocator>
  482. inline bool
  483. operator>= (const charT* lhs, const basic_string <charT, traits, Allocator>& rhs)
  484. {
  485.   return (rhs.compare (lhs) <= 0);
  486. }
  487. template <class charT, class traits, class Allocator>
  488. inline bool
  489. operator>= (const basic_string <charT, traits, Allocator>& lhs, const charT* rhs)
  490. {
  491.   return (lhs.compare (rhs) >= 0);
  492. }
  493. template <class charT, class traits, class Allocator>
  494. inline bool
  495. operator!= (const basic_string <charT, traits, Allocator>& lhs,
  496.     const basic_string <charT, traits, Allocator>& rhs)
  497. {
  498.   return (lhs.compare (rhs) != 0);
  499. }
  500. template <class charT, class traits, class Allocator>
  501. inline bool
  502. operator> (const basic_string <charT, traits, Allocator>& lhs,
  503.    const basic_string <charT, traits, Allocator>& rhs)
  504. {
  505.   return (lhs.compare (rhs) > 0);
  506. }
  507. template <class charT, class traits, class Allocator>
  508. inline bool
  509. operator<= (const basic_string <charT, traits, Allocator>& lhs,
  510.     const basic_string <charT, traits, Allocator>& rhs)
  511. {
  512.   return (lhs.compare (rhs) <= 0);
  513. }
  514. template <class charT, class traits, class Allocator>
  515. inline bool
  516. operator>= (const basic_string <charT, traits, Allocator>& lhs,
  517.     const basic_string <charT, traits, Allocator>& rhs)
  518. {
  519.   return (lhs.compare (rhs) >= 0);
  520. }
  521. class istream; class ostream;
  522. template <class charT, class traits, class Allocator> istream&
  523. operator>> (istream&, basic_string <charT, traits, Allocator>&);
  524. template <class charT, class traits, class Allocator> ostream&
  525. operator<< (ostream&, const basic_string <charT, traits, Allocator>&);
  526. template <class charT, class traits, class Allocator> istream&
  527. getline (istream&, basic_string <charT, traits, Allocator>&, charT delim = 'n');
  528. } // extern "C++"
  529. #include <std/bastring.cc>
  530. #endif