API tools faq
paste
Advertisement
Guest User

pistring.h

a guest
Dec 17th, 2010
1,017
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 17.87 KB | None | 0 0
raw download clone embed print report
  1. /*Created by: PiMaster
  2.  
  3. Member Functions:
  4.     inline const char* c_str() const - return the data of the string as a const c string
  5.     clear() - clear the contents of the string (no return)
  6.     insert(const char c,const unsigned pos) - inserts a character at pos (returns new length)
  7.     insert(const char* str,const unsigned pos) - inserts a c-string at pos (returns new length)
  8.     insert(const string& str,const unsigned pos) - inserts a string at pos (returns new length)
  9.     count(const char c) - returns the number of occurrences of c
  10.     count(const char* str) - returns the number of occurrences of str
  11.     count(const string& str) - returns the number of occurrences of str
  12.     replace(const char* str1,const char* str2) - replace all occurrences of str1 with str2 (returns number of occurrences)
  13.     replace(const string& str1,const char* str2) - replace all occurrences of str1 with str2 (returns number of occurrences)
  14.     replace(const char* str1,const string& str2) - replace all occurrences of str1 with str2 (returns number of occurrences)
  15.     replace(const string& str1,const string& str2) - replace all occurrences of str1 with str2 (returns number of occurrences)
  16.     erase(const unsigned start,const unsigned end) - erase data between start and end (returns new length)
  17.     find(const char c,unsigned n,unsigned start=0) - returns the position of the nth occurrence of c starting at start
  18.     find(const char* str,unsigned n,unsigned start=0) - returns the position of the nth occurrence of str starting at start
  19.     find(const string& str,unsigned n,unsigned start=0) - returns the position of the nth occurrence of str starting at start
  20.     rfind(const char c,unsigned n,unsigned start) - returns the position of the nth occurrence of c going backwards starting at start
  21.     rfind(const char* str,unsigned n,unsigned start) - returns the position of the nth occurrence of str going backwards starting at start
  22.     rfind(const string& str,unsigned n,unsigned start) - returns the position of the nth occurrence of str going backwards starting at start
  23.     reserve(const unsigned newsize) - request a new maximum size for the string (returns new size)
  24.         NOTE: If newsize is less than the current size, the reallocation will NOT happen
  25.     upper() - make all letters in the string uppercase (no return)
  26.     lower() - make all letters in the string lowercase (no return)
  27.     length() - returns the length of the string
  28.     capacity() - returns the capacity of the string (size of the buffer)
  29.  
  30. Member Operators:
  31.     inline operator char*() - converts the string to a c string
  32.     inline operator const char*() - converts the string to a const c string
  33.     inline char& operator[](const int x) - returns the character at index x
  34.         NOTE: If x is greater than the string length, it will return a reference to stroob
  35.     inline const char& operator[](const int x) const - returns the const character at index x
  36.         NOTE: If x is greater than the string length, it will return a reference to stroob
  37.     string& operator=(const char c) - sets the string equal to c (NULL terminated) (returns the string)
  38.     string& operator=(const char* str) - sets the string equal to str (returns the string)
  39.     string& operator=(const string& str) - sets the string equal to str (returns the string)
  40.     string& operator+=(const char c) - appends c to the string (returns the string)
  41.     string& operator+=(const char* str) - appends str to the string (returns the string)
  42.     string& operator+=(cosnt string& str) - appends str to the string (returns the string)
  43.  
  44. Global Operators:
  45.     bool operator==(const string& str1,const string& str2) - returns if str1 is equal to str2
  46.     bool operator==(const string& str1,const char* str2) - returns if str1 is equal to str2
  47.     bool operator==(const char* str1,const string& str2) - returns if str1 is equal to str2
  48.     bool operator!=(const string& str1,const string& str2) - returns if str1 is not equal to str2
  49.     bool operator!=(const string& str1,const char* str2) - returns if str1 is not equal to str2
  50.     bool operator!=(const char* str1,const string& str2) - returns if str1 is not equal to str2
  51.     bool operator>(const string& str1,const string& str2) - returns if the length of str1 is greater than the length of str2
  52.     bool operator>(const string& str1,const char* str2) - returns if the length of str1 is greater than the length of str2
  53.     bool operator>(const char* str1,const string& str2) - returns if the length of str1 is greater than the length of str2
  54.     bool operator<(const string& str1,const string& str2) - returns if the length of str1 is less than the length of str2
  55.     bool operator<(const string& str1,const char* str2) - returns if the length of str1 is less than the length of str2
  56.     bool operator<(const char* str1,const string& str2) - returns if the length of str1 is less than the length of str2
  57.     bool operator>=(const string& str1,const string& str2) - returns if the length of str1 is greater than or equal to the length of str2
  58.     bool operator>=(const string& str1,const char* str2) - returns if the length of str1 is greater than or equal to the length of str2
  59.     bool operator>=(const char* str1,const string& str2) - returns if the length of str1 is greater than or equal to the length of str2
  60.     bool operator<=(const string& str1,const string& str2) - returns if the length of str1 is less than or equal to the length of str2
  61.     bool operator<=(const string& str1,const char* str2) - returns if the length of str1 is less than or equal to the length of str2
  62.     bool operator<=(const char* str1,const string& str2) - returns if the length of str1 is less than or equal to the length of str2
  63.  
  64. */
  65.  
  66. #pragma once
  67. #ifndef PISTRING
  68. #define PISTRING
  69.  
  70. #ifndef NULL
  71. #define NULL 0
  72. #endif
  73.  
  74. char stroob=0;
  75.  
  76. struct string{
  77.     private:
  78.     //memory related functions
  79.         //resize the string data array
  80.         void resizedata(unsigned newsize){
  81.             //minimum buffer size
  82.             if(newsize<minbuffsize){
  83.                 newsize=minbuffsize;}
  84.             char* tmp=new char[datasize+newsize];
  85.             if(data!=NULL){
  86.                 memcpy(tmp,data,datalen+1);
  87.                 delete[] data;}
  88.             data=tmp;
  89.             datasize+=newsize;}
  90.         //doesn't check for memory overlapping
  91.         void* memcpy(void* dst,const void* src,const unsigned len){
  92.             if(dst==NULL || src==NULL || len==0){
  93.                 return NULL;}
  94.             char* d=(char*)dst;
  95.             char* s=(char*)src;
  96.             unsigned n=0;
  97.             while(n<len){
  98.                 *d=*s;
  99.                 ++d;
  100.                 ++s;
  101.                 ++n;}
  102.             return dst;}
  103.         //does check for memory overlapping
  104.         void* memmove(void* dst,const void* src,unsigned len){
  105.             if(dst==NULL || src==NULL || len==0){
  106.                 return NULL;}
  107.             char* d=(char*)dst;
  108.             char* s=(char*)src;
  109.             unsigned n=0;
  110.             //if dst is potentially overlapping src
  111.             if(d>s){
  112.                 d+=len;
  113.                 s+=len;
  114.                 while(n<len){
  115.                     *d=*s;
  116.                     ++d;
  117.                     ++s;
  118.                     ++n;}}
  119.             else{
  120.                 while(n<len){
  121.                     *d=*s;
  122.                     ++d;
  123.                     ++s;
  124.                     ++n;}}
  125.             return dst;}
  126.         unsigned strlen(const char* str) const{
  127.             unsigned x=0;
  128.             while(str[x]!=0){
  129.                 ++x;}
  130.             return x;}
  131.     //functions that are called by other functions
  132.         //count the number of occurrences of str
  133.         unsigned countstr(const char* str,const unsigned size) const{
  134.             unsigned x,pos=0,n=0;
  135.             while(pos<=datalen){
  136.                 //check if we found the string
  137.                 for(x=0;x<size && pos<=datalen;++x,++pos){
  138.                     if(data[pos]!=str[x]){
  139.                         break;}}
  140.                 if(x==size){
  141.                     ++n;}
  142.                 else{
  143.                     ++pos;}}
  144.             return n;}
  145.         //replace every occurrence of str1 with str2 a maximum of num times
  146.         unsigned replacestr(const char* str1,const char* str2,const unsigned size1,const unsigned size2,const unsigned num){
  147.             unsigned c=countstr(str1,size1);
  148.             if(datalen+(size2-size1)*c>datasize){
  149.                 resizedata(((size2-size1)*c)<<1);}
  150.             unsigned x,pos=0,n=0;
  151.             while(pos<=datalen && n<num){
  152.                 for(x=0;x<size1 && pos<=datalen;++x,++pos){
  153.                     if(data[pos]!=str1[x]){
  154.                         break;}}
  155.                 if(x==size1){
  156.                     memmove(data+pos+size2-size1,data+pos,datalen+size2-size1);
  157.                     memcpy(data+pos-size1,str2,size2);
  158.                     ++n;}
  159.                 else{
  160.                     ++pos;}}
  161.             datalen+=(size2-size1)*n;
  162.             return n;}
  163.         //find the nth occurrence of str starting at x
  164.         unsigned findstr(const char* str,const unsigned s,unsigned x,const unsigned n) const{
  165.             unsigned pos,c=0;
  166.             for(x=0;x<datalen;++x){
  167.                 for(pos=0;pos<s;++pos){
  168.                     if(data[x+pos]!=str[pos]){
  169.                         break;}}
  170.                 if(pos==s){
  171.                     if(c==n){
  172.                         return x;}
  173.                     else{
  174.                         ++c;}}}
  175.             return datalen+1;}
  176.         //find the nth occurrence of str starting at x going backwards
  177.         unsigned rfindstr(const char* str,const unsigned s,unsigned x,const unsigned n) const{
  178.             unsigned pos,c=0;
  179.             for(;x<datalen;--x){
  180.                 for(pos=0;pos<s;++pos){
  181.                     if(data[x+pos]!=str[pos]){
  182.                         break;}}
  183.                 if(pos==s){
  184.                     if(c==n){
  185.                         return x;}
  186.                     else{
  187.                         ++c;}}
  188.                 else{
  189.                     x-=pos;}}
  190.             return datalen+1;}
  191.     //constants
  192.         //maximum unsigned integer
  193.         const static unsigned maxint=~0;
  194.         //difference between 'a' and 'A' (used in upper() and lower() functions)
  195.         const static unsigned aA_diff='a'-'A';
  196.         //the maximum buffer size
  197.         const static unsigned minbuffsize=32;
  198.     //friends
  199.         //operators
  200.         //equal
  201.         friend bool operator==(const string&,const string&);
  202.         friend bool operator==(const string&,const char*);
  203.         friend bool operator==(const char*,const string&);
  204.         //not equal
  205.         friend bool operator!=(const string&,const string&);
  206.         friend bool operator!=(const string&,const char*);
  207.         friend bool operator!=(const char*,const string&);
  208.         //greater than
  209.         friend bool operator>(const string&,const string&);
  210.         friend bool operator>(const string&,const char*);
  211.         friend bool operator>(const char*,const string&);
  212.         //less than
  213.         friend bool operator<(const string&,const string&);
  214.         friend bool operator<(const string&,const char*);
  215.         friend bool operator<(const char*,const string&);
  216.         //greater than or equal to
  217.         friend bool operator>=(const string&,const string&);
  218.         friend bool operator>=(const string&,const char*);
  219.         friend bool operator>=(const char*,const string&);
  220.         //less than or equal to
  221.         friend bool operator<=(const string&,const string&);
  222.         friend bool operator<=(const string&,const char*);
  223.         friend bool operator<=(const char*,const string&);
  224.     protected:
  225.         //data
  226.         char* data;
  227.         unsigned datasize,datalen;
  228.     public:
  229.         string(){
  230.             data=new char[32];
  231.             data[0]=0;
  232.             datasize=32;
  233.             datalen=0;}
  234.         string(const char* str){
  235.             unsigned s=strlen(str);
  236.             data=new char[s+minbuffsize];
  237.             memcpy(data,str,s+1);
  238.             datasize=s+minbuffsize;
  239.             datalen=s;}
  240.         string(const string& str){
  241.             data=new char[str.datasize];
  242.             memcpy(data,str.data,str.datalen+1);
  243.             datasize=str.datasize;
  244.             datalen=str.datalen;}
  245.         ~string(){
  246.             delete[] data;}
  247.         inline operator const char*() const{
  248.             return data;}
  249.         inline const char* c_str() const{
  250.             return data;}
  251.         inline char& operator[](const unsigned x){
  252.             if(x>datalen){
  253.                 return stroob;}
  254.             return data[x];}
  255.         inline const char& operator[](const unsigned x) const{
  256.             if(x>datalen){
  257.                 return stroob;}
  258.             return data[x];}
  259.         string& operator=(const char c){
  260.             if(2>datasize){
  261.                 resizedata(minbuffsize+1-datasize);}
  262.             data[0]=c;
  263.             data[1]=0;
  264.             datalen=1;
  265.             return *this;}
  266.         string& operator=(const char* str){
  267.             unsigned s=strlen(str);
  268.             if(s+1>datasize){
  269.                 resizedata(s<<1-datasize);}
  270.             memcpy(data,str,s+1);
  271.             datalen=s;
  272.             return *this;}
  273.         string& operator=(const string& str){
  274.             datalen=str.datalen;
  275.             if(datalen+1>datasize){
  276.                 resizedata(datalen<<1-datasize);}
  277.             memcpy(data,str.data,datalen+1);
  278.             return *this;}
  279.         string& operator+=(const char c){
  280.             if(datalen+2>datasize){
  281.                 resizedata(minbuffsize);}
  282.             data[datalen]=c;
  283.             data[datalen+1]=0;
  284.             ++datalen;
  285.             return *this;}
  286.         string& operator+=(const char* str){
  287.             unsigned s=strlen(str);
  288.             if(datalen+s+1>datasize){
  289.                 resizedata(s<<1);}
  290.             memcpy(data+datalen,str,s+1);
  291.             datalen+=s;
  292.             return *this;}
  293.         string& operator+=(const string& str){
  294.             if(datalen+str.datalen+1>datasize){
  295.                 resizedata(str.datalen<<2);}
  296.             memcpy(data+datalen,str.data,str.datalen+1);
  297.             datalen+=str.datalen;
  298.             return *this;}
  299.         void clear(){
  300.             data[0]=0;}
  301.         unsigned insert(const char c,const unsigned pos){
  302.             if(datalen+2>datasize){
  303.                 resizedata(minbuffsize);}
  304.             memmove(data+pos+1,data+pos,datalen-pos);
  305.             data[pos]=c;
  306.             ++datalen;
  307.             return datalen;}
  308.         unsigned insert(const char* str,const unsigned pos){
  309.             unsigned s=strlen(str);
  310.             if(datalen+s+1>datasize){
  311.                 resizedata(s<<2);}
  312.             memmove(data+pos+s,data+pos,datalen-pos);
  313.             memcpy(data+pos,str,s);
  314.             datalen+=s;
  315.             return datalen;}
  316.         unsigned insert(const string& str,const unsigned pos){
  317.             if(datalen+str.datalen+1>datasize){
  318.                 resizedata(str.datalen<<1);}
  319.             memmove(data+pos+str.datalen,data+pos,datalen-pos);
  320.             memcpy(data+pos,str.data,str.datalen);
  321.             datalen+=str.datalen;
  322.             return datalen;}
  323.         //count
  324.         unsigned count(const char c) const{
  325.             return countstr(&c,1);}
  326.         unsigned count(const char* str) const{
  327.             return countstr(str,strlen(str));}
  328.         unsigned count(const string& str) const{
  329.             return countstr(str.data,str.datalen);}
  330.         //replace
  331.         unsigned replace(const char* str1,const char* str2,unsigned num=maxint){
  332.             return replacestr(str1,str2,strlen(str1),strlen(str2),num);}
  333.         unsigned replace(const string& str1,const char* str2,unsigned num=maxint){
  334.             return replacestr(str1.data,str2,str1.datalen,strlen(str2),num);}
  335.         unsigned replace(const char* str1,const string& str2,unsigned num=maxint){
  336.             return replacestr(str1,str2.data,strlen(str1),str2.datalen,num);}
  337.         unsigned replace(const string& str1,const string& str2,unsigned num=maxint){
  338.             return replacestr(str1.data,str2.data,str1.datalen,str2.datalen,num);}
  339.         //erase
  340.         unsigned erase(const unsigned start,const unsigned end){
  341.             memmove(data+start,data+end,datalen-end+1);
  342.             datalen-=end-start;
  343.             return datalen;}
  344.         //find
  345.         unsigned find(const char c,unsigned n=0,unsigned start=0) const{
  346.             return findstr(&c,1,start,n);}
  347.         unsigned find(const char* str,unsigned n=0,unsigned start=0) const{
  348.             return findstr(str,strlen(str),start,n);}
  349.         unsigned find(const string& str,unsigned n=0,unsigned start=0) const{
  350.             return findstr(str.data,str.datalen,start,n);}
  351.         //rfind (reverse find)
  352.         unsigned rfind(const char c,unsigned n=0,unsigned start=maxint) const{
  353.             if(start==maxint){
  354.                 start=datalen;}
  355.             return rfindstr(&c,1,start,n);}
  356.         unsigned rfind(const char* str,unsigned n=0,unsigned start=maxint) const{
  357.             if(start==maxint){
  358.                 start=datalen;}
  359.             return rfindstr(str,strlen(str),start,n);}
  360.         unsigned rfind(const string& str,unsigned n=0,unsigned start=maxint) const{
  361.             if(start==maxint){
  362.                 start=datalen;}
  363.             return rfindstr(str,strlen(str),start,n);}
  364.         //reserve
  365.         int reserve(const int newsize){
  366.             int size=(newsize>datasize?newsize:datasize);
  367.             char* tmp=new char[size];
  368.             memcpy(tmp,data,datalen);
  369.             delete[] data;
  370.             data=tmp;
  371.             datasize=size;
  372.             return size;}
  373.         void upper(){
  374.             unsigned pos=0;
  375.             while(pos<=datalen){
  376.                 if(data[pos]>='a' && data[pos]<='z'){
  377.                     data[pos]-=aA_diff;}
  378.                 ++pos;}}
  379.         void lower(){
  380.             unsigned pos=0;
  381.             while(pos<=datalen){
  382.                 if(data[pos]>='A' && data[pos]<='Z'){
  383.                     data[pos]+=aA_diff;}
  384.                 ++pos;}}
  385.         unsigned length() const{
  386.             return datalen;}
  387.         unsigned capacity() const{
  388.             return datasize;}};
  389.  
  390. //I couldn't use the ones defined in the string class, so I made an obscurely named namespace to hide them
  391. //(this isn't bad practice, is it?)
  392. namespace strexternalfuncs{
  393.     bool isequal(const char* str1,const char* str2,const unsigned len1,const unsigned len2){
  394.         if(len1!=len2){
  395.             return false;}
  396.         unsigned pos=0;
  397.         while(pos<len1){
  398.             if(str1[pos]!=str2[pos]){
  399.                 return false;}
  400.             ++pos;}
  401.         return true;}
  402.     unsigned strlen(const char* str){
  403.         unsigned x;
  404.         while(str[x]!=0){
  405.             ++x;}
  406.         return x;}};
  407.  
  408. //global operators
  409. //equal
  410. bool operator==(const string& str1,const string& str2){
  411.     return strexternalfuncs::isequal(str1.data,str2.data,str1.datalen,str2.datalen);}
  412.  
  413. bool operator==(const string& str1,const char* str2){
  414.     return strexternalfuncs::isequal(str1.data,str2,str1.datalen,strexternalfuncs::strlen(str2));}
  415.  
  416. bool operator==(const char* str1,const string& str2){
  417.     return strexternalfuncs::isequal(str1,str2.data,strexternalfuncs::strlen(str1),str2.datalen);}
  418.  
  419. //not equal
  420. bool operator!=(const string& str1,const string& str2){
  421.     return !strexternalfuncs::isequal(str1.data,str2.data,str1.datalen,str2.datalen);}
  422.  
  423. bool operator!=(const string& str1,const char* str2){
  424.     return !strexternalfuncs::isequal(str1.data,str2,str1.datalen,strexternalfuncs::strlen(str2));}
  425.  
  426. bool operator!=(const char* str1,const string& str2){
  427.     return !strexternalfuncs::isequal(str1,str2.data,strexternalfuncs::strlen(str1),str2.datalen);}
  428.  
  429. //greater than
  430. bool operator>(const string& str1,const string& str2){
  431.     return str1.datalen>str2.datalen;}
  432.  
  433. bool operator>(const string& str1,const char* str2){
  434.     return str1.datalen>strexternalfuncs::strlen(str2);}
  435.  
  436. bool operator>(const char* str1,const string& str2){
  437.     return strexternalfuncs::strlen(str1)>str2.datalen;}
  438.  
  439. //less than
  440. bool operator<(const string& str1,const string& str2){
  441.     return str1.datalen<str2.datalen;}
  442.  
  443. bool operator<(const string& str1,const char* str2){
  444.     return str1.datalen<strexternalfuncs::strlen(str2);}
  445.  
  446. bool operator<(const char* str1,const string& str2){
  447.     return strexternalfuncs::strlen(str1)<str2.datalen;}
  448.  
  449. //greater than or equal to
  450. bool operator>=(const string& str1,const string& str2){
  451.     return str1.datalen>=str2.datalen;}
  452.  
  453. bool operator>=(const string& str1,const char* str2){
  454.     return str1.datalen>=strexternalfuncs::strlen(str2);}
  455.  
  456. bool operator>=(const char* str1,const string& str2){
  457.     return strexternalfuncs::strlen(str1)>=str2.datalen;}
  458.  
  459. //less than or equal to
  460. bool operator<=(const string& str1,const string& str2){
  461.     return str1.datalen<=str2.datalen;}
  462.  
  463. bool operator<=(const string& str1,const char* str2){
  464.     return str1.datalen<=strexternalfuncs::strlen(str2);}
  465.  
  466. bool operator<=(const char* str1,const string& str2){
  467.     return strexternalfuncs::strlen(str1)<=str2.datalen;}
  468.  
  469. #endif
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!