home *** CD-ROM | disk | FTP | other *** search
/ Turbo Toolbox / Turbo_Toolbox.iso / 1991 / 02 / grdlagen / cstring.cpp < prev    next >
Encoding:
Text File  |  1990-12-11  |  3.5 KB  |  187 lines
  1. //----------------------------------------------------------
  2. //                      CSTRING.CPP                        -
  3. //        (c) 1991 by Thole Groeneveld & toolbox           -
  4. //----------------------------------------------------------
  5.  
  6. #include "cstring.h"
  7.  
  8. void DefaultStringErrHandler() {
  9.  cerr << "ERROR : STRING OUT OF RANGE\n";
  10. }
  11.  
  12. void (*String::ErrHandler)() = DefaultStringErrHandler;
  13.  
  14. String::String()
  15. {
  16.  length = 0;
  17.  str = new char;
  18.  str[0] = 0;
  19. }
  20.  
  21. String::String (const char *s)
  22. {
  23.  length = strlen(s);
  24.  str = new char[length + 1];
  25.  strcpy (str, s);
  26. }
  27.  
  28. String::String (const String& s)
  29. {
  30.  length = s.length;
  31.  str = new char[length + 1];
  32.  strcpy (str, s.str);
  33. }
  34.  
  35. String::String (unsigned n)
  36. {
  37.  length = n;
  38.  str = new char[n+1];
  39.  str[n] = 0;
  40. }
  41.  
  42. String String::Left (unsigned r)
  43. {
  44.  if (r > length) {
  45.      String::ErrHandler();
  46.      String s; return s;
  47.      }
  48.  else {
  49.      String tmp (r);
  50.      strncpy (tmp.str, str, r);
  51.      return tmp;
  52.       }
  53. }
  54.  
  55. String String::Right (unsigned l)
  56. {
  57.  if (l > length) {
  58.      String::ErrHandler();
  59.      String s; return s;
  60.     }
  61.  else {
  62.      String tmp (l);
  63.      strncpy (tmp.str, str + length - l, l);
  64.      return tmp;
  65.  }
  66. }
  67.  
  68. String& String::InsertAt (unsigned pos, const String& s)
  69. {
  70.  if (pos > length) {
  71.      String::ErrHandler();
  72.      return *this;
  73.     }
  74. int newLength = length + s.length;
  75. char *tmp = new char[newLength + 1];
  76. strncpy (tmp, str, pos);
  77. strcpy (tmp + pos, s.str);
  78. strcpy (tmp + pos + s.length, str + pos);
  79. delete str;
  80. length = newLength;
  81. str = tmp;
  82. return *this;
  83. }
  84.  
  85. String& String::WriteAt (unsigned pos, const String& s)
  86. {
  87.  if (pos > length) {
  88.      String::ErrHandler();
  89.      return *this;
  90.      }
  91.  int n = length - pos;
  92.  if (s.length < n)
  93.  n = s.length;
  94.  strncpy (str + pos, s.str, n);
  95.  return *this;
  96. }
  97.  
  98. String ToString (int i)
  99. {
  100.  char buffer[32];
  101.  sprintf (buffer, "%d", i);
  102.  String s(strlen(buffer) + 1);
  103.  strcpy (s.str, buffer);
  104. return s;
  105. }
  106.  
  107. String ToString (long l)
  108. {
  109.  char buffer[32];
  110.  sprintf (buffer, "%ld", l);
  111.  String s(strlen(buffer) + 1);
  112.  strcpy (s.str, buffer);
  113.  return s;
  114. }
  115.  
  116. String ToString (double d)
  117. {
  118.  char buffer[32];
  119.  sprintf (buffer, "%lf", d);
  120.  String s(strlen(buffer) + 1);
  121.  strcpy (s.str, buffer);
  122. return s;
  123. }
  124.  
  125. String& String::operator = (const String& s)
  126. {
  127.  delete str;
  128.  length = s.length;
  129.  str = new char[length + 1];
  130.  strcpy (str, s.str);
  131. return *this;
  132. }
  133.  
  134. String operator + (const String& s1, const String& s2)
  135. {
  136.  String tmp (s1.length + s2.length);
  137.  strcpy (tmp.str, s1.str);
  138.  strcpy (tmp.str + s1.length, s2.str);
  139. return tmp;
  140. }
  141.  
  142. void String::operator += (const String& s)
  143. {
  144.  char *tmp = new char[length + s.length + 1];
  145.  strcpy (tmp, str);
  146.  strcpy (tmp + length, s.str);
  147.  length += s.length;
  148.  delete str;
  149.  str = tmp;
  150. }
  151.  
  152. char& String::operator [] (unsigned n)
  153. {
  154. static char dummy;
  155. if ( n < length )
  156.      return str[n];
  157.  else {
  158.        String::ErrHandler();
  159.        return dummy;
  160.       }
  161. }
  162.  
  163. String String::operator () (unsigned l, unsigned r)
  164. {
  165.  if ( (l > r) || (r > length) )
  166.      {
  167.        String::ErrHandler();
  168.        String s; return s;
  169.      }
  170.  else {
  171.   int n = r - l + 1;
  172.   String tmp (n);
  173.   strncpy (tmp.str, str + l, n);
  174.   return tmp;
  175.  }
  176. }
  177.  
  178. istream& operator >> (istream& is, String& s)
  179. {
  180.  char buffer[256];
  181.  is.get (buffer, 256);
  182.  s = buffer;
  183.  return is;
  184. }
  185. //----------------------------------------------------------
  186. //                 Ende von CSTRING.CPP                    -
  187.