开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数值算法/人工智能 > 查看源码
_string.c
资源名称：leda.tar.gz　[点击查看]
上传用户：gzelex
上传日期：2007-01-07
资源大小：707k
文件大小：7k
源码类别：

数值算法/人工智能

开发平台：

MultiPlatform

_string.c：源码内容
  1. /*******************************************************************************
  2. +
  3. +  LEDA-R  3.2.3
  4. +
  5. +  _string.c
  6. +
  7. +  Copyright (c) 1995  by  Max-Planck-Institut fuer Informatik
  8. +  Im Stadtwald, 66123 Saarbruecken, Germany     
  9. +  All rights reserved.
  10. + 
  11. *******************************************************************************/
  14. #include <LEDA/basic.h>
  15. #include <LEDA/string.h>
  17. #include <stdio.h>
  18. #include <stdarg.h>
  19. #include <string.h>
  20. #include <ctype.h>
  23. //------------------------------------------------------------------------------
  24. // String
  25. //------------------------------------------------------------------------------
  27. string_rep::string_rep(const char* p) 
  28. { s = string::str_dup(p); }
  30. string_rep::string_rep(const char* p, const char* q) 
  31. { s = string::str_cat(p,q); }
  33. string_rep::string_rep(char c)   
  34. { char p[2];
  35.   p[0] = c;
  36.   p[1] = '';
  37.   s=string::str_dup(p); 
  38.  }
  40. char* string::str_dup(const char* p)
  41. { if (p==nil) error_handler(1,"string::str_dup: nil argument");
  42.   char* q = new char[strlen(p)+1];
  43.   if (q==nil) error_handler(1,"string::str_dup: out of memory");
  44.   strcpy(q,p);
  45.   return q;
  46. }
  48. char* string::str_cat(const char* p1, const char* p2)
  49. { char* q = new char[strlen(p1)+strlen(p2)+1];
  50.   if (q==nil) error_handler(1,"string::str_cat: out of memory");
  51.   strcpy(q,p1);
  52.   strcat(q,p2);
  53.   return q;
  54.  }
  56. char* string::str_ncat(int argc, char** argv)
  57. { int l=0;
  58.   int i;
  59.   for(i=0;i<argc;i++)  l += (strlen(argv[i])+1); 
  60.   char* q = new char[l+1];
  61.   if (q==nil) error_handler(1,"string::str_cat: out of memory");
  62.   q[0] = 0;
  63.   for(i=0;i<argc;i++)
  64.   { strcat(q,argv[i]);
  65.     strcat(q," ");
  66.    }
  67.   return q;
  68.  }
  70. void string::read(istream& s, char delim)
  71. { char buf[512];
  72.   char* q = buf+511;
  73.   bool go = true;
  75.   operator=(""); // clear string
  77.   while (s && go)
  78.   { char* p;
  79.     for(p = buf; p < q && s.get(*p); p++)
  80.     { if (*p == delim) 
  81.       { if (delim != 'n') s.putback(*p);
  82.         go = false;
  83.         break;
  84.        }
  85.      } 
  86.     *p = '';
  87.     operator+=(buf);
  88.    }
  90. }
  93. #define STRING_CONSTRUCTOR(type)                         
  94. string::string(const char* f, type x, ...)               
  95. { char buf1[512];                                        
  96.   char buf2[512];                                        
  97.   char* q = buf1;                                        
  98.   int first = 1;                                         
  99.   /* copy f to buf1 doubling all %'s except the first */ 
  100.   while(*f != '')                                      
  101.     if ((*q++ = *f++) == '%')                            
  102.       if (!first) *q++ = '%';                            
  103.       else first = 0;                                    
  104.   *q = '';                                             
  105.   /* insert first argument x*/                           
  106.   sprintf(buf2,buf1,x);                                  
  107.   /* insert the rest */                                  
  108.   va_list arg_list;                                      
  109.   va_start(arg_list,x);                                  
  110.   vsprintf(buf1,buf2,arg_list);                          
  111.   PTR = new string_rep(buf1);                            
  112. }
  113.     
  114.   
  115. STRING_CONSTRUCTOR(char)
  116. STRING_CONSTRUCTOR(unsigned char)
  117. STRING_CONSTRUCTOR(short)
  118. STRING_CONSTRUCTOR(unsigned short)
  119. STRING_CONSTRUCTOR(int)
  120. STRING_CONSTRUCTOR(unsigned int)
  121. STRING_CONSTRUCTOR(long)
  122. STRING_CONSTRUCTOR(unsigned long)
  123. STRING_CONSTRUCTOR(float)
  124. STRING_CONSTRUCTOR(double)
  125. STRING_CONSTRUCTOR(void*)
  128. int string::length() const  { return strlen(cstring()); }
  130. char string::operator[](int i) const
  131. { if (i<0 || length() <= i) 
  132.     error_handler(1,"string[]: index out of range");
  133.   return ptr()->s[i];
  134. }
  136. char& string::operator[](int i)
  137. { if (i<0 || length() <= i) 
  138.     error_handler(1,"string[]: index out of range");
  139.   if (refs() > 1) *this = cstring();    // disconnect
  140.   return ptr()->s[i];
  141. }
  143. string& string::operator+=(const string& x) 
  144. { *this = *this + x; 
  145.   return *this; 
  146.  }
  148. //friends
  150. string  operator+(const string& x ,const string& y)
  151. { return new string_rep(x.cstring(),y.cstring()); }
  153. bool operator==(const string& x, const string& y) 
  154. { if (x.ptr() == y.ptr()) return true;
  155.   return strcmp(x.cstring(),y.cstring())==0; 
  156.  }
  158. bool operator==(const string& x, const char* y) 
  159. { return strcmp(x.cstring(),y)==0; }
  161. bool operator!=(const string& x, const string& y) 
  162. { if (x.ptr() == y.ptr()) return false;
  163.   return strcmp(x.cstring(),y.cstring())!=0; 
  164.  }
  166. bool operator!=(const string& x, const char* y) 
  167. { return strcmp(x.cstring(),y)!=0; }
  169. bool operator<(const string& x, const string& y)  
  170. { return strcmp(x.cstring(),y.cstring())<0; }
  172. bool operator>(const string& x, const string& y)  
  173. { return strcmp(x.cstring(),y.cstring())>0; }
  175. bool operator<=(const string& x, const string& y) 
  176. { if (x.ptr() == y.ptr()) return true;
  177.   return strcmp(x.cstring(),y.cstring())<=0; 
  178.  }
  180. bool operator>=(const string& x, const string& y) 
  181. { if (x.ptr() == y.ptr()) return true;
  182.   return strcmp(x.cstring(),y.cstring())>=0; 
  183.  }
  187. istream& operator>>(istream& in, string& x)
  188. { char buf[256];
  189.   char* p = buf;
  191.   //skip leading white space (but not eol if in = cin)
  192.   while (in.get(*p) && isspace(*p) && (&in != &cin || *p != 'n')); 
  194.   if (in && *p != 'n')
  195.   { p++;
  196.     while (in.get(*p) && !isspace(*p)) p++;
  197.    }
  199.   *p = '';
  200.   x.operator=(buf);
  201.   return in;
  202. }
  205. ostream& operator<<(ostream& out, const string& x) 
  206. { return out << x.cstring(); }
  209. string string::sub(int i, int j) const
  210. {
  211.   if (j >= length()) j = length() - 1;
  213.   if (i < 0) i = 0;
  215.   int l = j-i+1;
  217.   if (l <= 0)  return string("");
  219.   char* q = new char[l+1];
  220.   strncpy(q,cstring()+i,l);
  221.   q[l] = '';
  223.   string s(q);
  224.   delete[] q;
  225.   return s;
  226. }
  228. int string::pos(string s1, int i) const
  229. {
  230.   int l1 = s1.length();
  231.   if (l1==0 || i >= length()) return -1;
  233.   char c = s1[0];
  235.   char* q = cstring() + i;
  236.   while (*q)
  237.     { while ( (*q) && (*q != c) ) q++;
  238.       if ( strncmp(q,s1.cstring(),l1)==0 ) break ;
  239.       if (*q) q++;
  240.      }
  241.   return (*q) ? int((q - cstring())/ sizeof(char)) :  -1;
  242. }
  244. string string::insert(string s, int i) const
  245. { return sub(0,i-1) + s + sub(i,length()-1); }
  247. string string::insert(int i, string s) const
  248. { return sub(0,i-1) + s + sub(i,length()-1); }
  251. string string::del(int i, int j) const
  252. { return sub(0,i-1) + sub(j+1,length()-1); }
  254. string string::del(const string& s, int n) const
  255. { return replace(s,"",n); }
  259. string string::replace(int i, int j, const string& s) const
  260. { return sub(0,i-1) + s + sub(j+1,length()-1); }
  262. string string::replace(const string& s1, const string& s2, int n) const 
  263. { 
  264.   // replace n-th (all if n=0) occurrence of s1 by s2 
  266.   int i = 0;
  267.   int match = 0;  
  269.   int l1 = s1.length();
  271.   string tmp;
  273.   for(;;)
  274.   { int j = pos(s1,i);
  275.     if (j < 0 ) break;
  276.     tmp += sub(i,j-1);
  278.     if (n==0 || ++match == n)
  279.        tmp += s2;
  280.     else
  281.        tmp += s1;
  283.     i = j+l1;
  284.    }
  286.   tmp += sub(i,length()-1);
  288.   return tmp;
  290.  }
  293. string string::format(string f) const
  294. { 
  295.   char buf[512];
  296.   sprintf(buf,~f,cstring());
  297.   return buf;
  299.  }
  302. int string::cmp(const string& x, const string& y) { return strcmp(x,y); }