API tools faq
paste
Guest User

pistring.h

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