c++中string类的源代码


一:回顾

(1)c++中的string类是在面试中和笔试中经常考的题目; 工程代码免费下载 string类的自行实现

(2)c++中的string类和fstream类合起来是处理外部数据的利器

(3)string类经常用到find find_first_of find_first_not_of find_last_of find_last_not_of substr replace等,以及联合使用来达到java中的split和trim

  (4) 使用friend 仅仅是在类中进行声明的非内部 却可以访问内部成员的外部函数,而且在外部不再需要friend关键字;它与成员函数的区别是,friend和外部函数不含有this对象指针;本文用到了const 定义的全局最大值最小值变量(代替#define)

 (5) 有些函数返回的是MyString& 、Char& 等(引用),MyString、Char 等(传值)这得看你返回的对象是函数的局部变量还是全局变量(或者类当前对象成员变量);前者只能返回一个MyString、Char 等;后者强烈建议返回MyString& 、Char& 等(引用);

(6)有些函数的参数是const MyString& ,有些是MyString& (引用);这是为什么?前者是把外部值传提到子函数内部,且不允许改变;后者是作为函数的返回值传递进去的,返回的结果为函数的处理结果(而不用函数自身返回值了)。

二:下面是简单的实现了一下string类,参照的是STL源码,但是自己理解的还是不够深,难免有一些错误,请各位指教

(1)MyString.h文件

  1. #ifndef MYSTRING_H  
  2. #define MYSTRING_H  
  3. #include "MyExcept.h"  
  4. #include <cstring>  
  5. #include <iostream>  
  6. const int INI_MAX = 0x7fffffff;//2^32npos  
  7. const int INI_MIN = 0x80000000;// -2^32  
  8. const int npos = 0xffffffff;// npos  
  9. using namespace std;  
  10.   
  11. class MyString  
  12. {  
  13.     public:  
  14.     // constructor  
  15.     MyString();//  
  16.     MyString(const MyString &);//  
  17.     MyString(const char *);  
  18.     MyString(const size_t,const char);  
  19.     // destructor  
  20.     ~MyString();  
  21.     // attributes  
  22.   
  23.     size_t length();// 字符串长度  
  24.     bool isEmpty();// 返回字符串是否为空  
  25.     const char* c_str();// 返回c风格的trr的指针  
  26.     // friend funs  
  27.     // read writer operations  
  28.     friend ostream& operator<< (ostream&, const MyString&);  
  29.     friend istream& operator>> (istream&, MyString&);  
  30.     //add operation  
  31.     friend MyString operator+(const MyString&,const MyString&);  
  32.     // compare operations  
  33.     friend bool operator==(const MyString&,const MyString&);  
  34.     friend bool operator!=(const MyString&,const MyString&);  
  35.     friend bool operator<(const MyString&,const MyString&);  
  36.     friend bool operator<=(const MyString&,const MyString&);  
  37.     friend bool operator>(const MyString&,const MyString&);  
  38.     friend bool operator>=(const MyString&,const MyString&);  
  39.     // 成员函数实现运算符重载,其实一般需要返回自身对象的,成员函数运算符重载会好一些  
  40.     // index operation  
  41.     char& operator[](const size_t);  
  42.     const char& operator[](const size_t)const;  
  43.     // =  
  44.     MyString& operator=(const MyString&);  
  45.     // +=  
  46.     MyString& operator+=(const MyString&);  
  47.     // +=  
  48.     //MyString operator+=(const MyString&); cannot be overloaded  
  49.     // 成员操作函数  
  50.     // substr  
  51.     MyString substr(size_t pos,const size_t n);  
  52.     // append  
  53.     MyString& append(const MyString&);  
  54.     //insert  
  55.     MyString& insert(size_t,const MyString&);  
  56.     //assign 替换  
  57.     MyString& assign(MyString&,size_t,size_t);  
  58.     // erase 删除  
  59.     MyString& erase(size_t,size_t);  
  60.     //find_first_of 查找某一个字符 size_t 是非符号数的,重载  
  61.     // 查找在字符串中第一个与str中的某个字符匹配的字符,返回它的位置。  
  62.     //搜索从index开始,如果没找到就返回string::npos  
  63.     int find_first_of(const char* str,size_t index=0);  
  64.     int find_first_of(const char ch,size_t index=0);  
  65.     int find_first_of(const MyString &,size_t index=0);  
  66.     // 在字符串中查找第一个与str中的字符都不匹配的字符,返回它的位置。搜索从index开始。如果没找到就返回string::nops  
  67.     int find_first_not_of(const char* str,size_t index=0);  
  68.     int find_first_not_of(const char ch,size_t index=0);  
  69.     int find_first_not_of(const MyString&,size_t index=0);  
  70.     // swap  
  71.     void swap(MyString& lhs,MyString& rhs);  
  72.     // replace_all  
  73.     MyString& replace_all(const char oldc,const char newc=NULL);  
  74.     MyString& replace(size_t index,size_t num1,size_t num2,const char ch);  
  75.     //find  
  76.     int find(const char* str,size_t index=0);  
  77.     int find(const MyString& str,size_t index=0);  
  78.     int find(const char ch,size_t index=0);  
  79.   
  80.   
  81.     //private  
  82.     private:  
  83.     char *p_str;  
  84.     size_t strLength;  
  85. };  
  86.   
  87.   
  88. #endif // MYSTRING_H  

(2)MyString.cpp文件

  1. #include "MyString.h"  
  2. #include <cassert>  
  3.   
  4. // constructor  
  5.     MyString::MyString():p_str(NULL),strLength(0){}  
  6.   
  7.     MyString::MyString(const MyString &str)//  
  8.     {  
  9.         if(NULL == str.p_str)  
  10.         {  
  11.             return;  
  12.         }  
  13.         strLength = str.strLength;  
  14.         p_str = new char[strLength+1];  
  15.         strcpy(p_str,str.p_str);  
  16.     }  
  17.     MyString::MyString(const char *str)  
  18.     {  
  19.         if(NULL == str)  
  20.         {  
  21.             return;  
  22.         }  
  23.         strLength = strlen(str);  
  24.         p_str = new char[strLength+1];  
  25.         strcpy(p_str,str);  
  26.     }  
  27.     MyString::MyString(const size_t len,const char ch)  
  28.     {  
  29.         if(NULL == ch)  
  30.         {  
  31.             return;  
  32.         }  
  33.         strLength = len;  
  34.         p_str = new char[strLength+1];  
  35.         for(size_t i=0;i<strLength;i++)  
  36.         {  
  37.             p_str[i] = ch;  
  38.         }  
  39.         p_str[strLength] = '\0';// 因为strset以'\0'结束的  
  40.         cout << p_str << " &&" << endl;  
  41.         //strset(p_str,ch);  
  42.         //cout << p_str[0] << ",,,"<<strlen(p_str) << "," << strLength << endl;  
  43.     }  
  44.     // destructor  
  45.     MyString::~MyString()  
  46.     {  
  47.         delete[] p_str;  
  48.     }  
  49.   
  50.     // attributes  
  51.     size_t MyString::length()// 字符串长度  
  52.     {  
  53.         return strLength;  
  54.     }  
  55.     bool MyString::isEmpty()// 返回字符串是否为空  
  56.     {  
  57.         return strLength==0?true:false;  
  58.     }  
  59.     const char* MyString::c_str()  
  60.     {  
  61.         return p_str;  
  62.     }  
  63.     // 为什么不是引用呢??? friend 使用在类里面进行声明的,外面就不需要了,而且友元函数不属于类的成员函数,所以不用MyString::  
  64.     // ostream  
  65.     ostream& operator<< (ostream& out,const MyString &str)  
  66.     {  
  67.         if(str.p_str != NULL)  
  68.         {  
  69.             out << str.p_str;  
  70.         }  
  71.         return out;  
  72.     }  
  73.     // istream,一个是const另一个不是,根据变还是不变  
  74.     istream& operator>> (istream& in, MyString& str)  
  75.     {  
  76.         char tmp[100];// 临时字符串  
  77.         if(in>>tmp)  
  78.         {  
  79.             delete[] str.p_str;  
  80.             str.strLength = strlen(tmp);  
  81.             str.p_str = new char[str.strLength+1];  
  82.             strcpy(str.p_str,tmp);  
  83.         }  
  84.         return in;  
  85.     }  
  86.     // + 加  
  87.     MyString operator+(const MyString& lhs,const MyString& rhs)  
  88.     {  
  89.         MyString ret;  
  90.         ret.strLength = lhs.strLength + rhs.strLength;  
  91.         ret.p_str = new char[ret.strLength+1];  
  92.         strcpy(ret.p_str,lhs.p_str);  
  93.         strcat(ret.p_str,rhs.p_str);  
  94.         return ret;  
  95.     }  
  96.     // compare operations  
  97.     bool operator==(const MyString& lhs,const MyString& rhs)  
  98.     {  
  99.         return strcmp(lhs.p_str,rhs.p_str)==0?true:false;  
  100.     }  
  101.     bool operator!=(const MyString& lhs,const MyString& rhs)  
  102.     {  
  103.         return strcmp(lhs.p_str,rhs.p_str)!=0?true:false;  
  104.     }  
  105.     bool operator<(const MyString& lhs,const MyString& rhs)  
  106.     {  
  107.         return strcmp(lhs.p_str,rhs.p_str)<0?true:false;  
  108.     }  
  109.     bool operator<=(const MyString& lhs,const MyString& rhs)  
  110.     {  
  111.         return strcmp(lhs.p_str,rhs.p_str)<=0?true:false;  
  112.     }  
  113.     bool operator>(const MyString& lhs,const MyString& rhs)  
  114.     {  
  115.         return strcmp(lhs.p_str,rhs.p_str)>0?true:false;  
  116.     }  
  117.     bool operator>=(const MyString& lhs,const MyString& rhs)  
  118.     {  
  119.         return strcmp(lhs.p_str,rhs.p_str)>=0?true:false;  
  120.     }  
  121.     // 成员函数实现运算符重载  
  122.     // index operation  
  123.     char& MyString::operator[](const size_t index)  
  124.     {  
  125.         if(index<0 || index>=strLength)  
  126.         {  
  127.             throw Outofbond() ;  
  128.         }  
  129.         return p_str[index];  
  130.     }  
  131.     const char& MyString::operator[](const size_t index)const  
  132.     {  
  133.         if(index<0 || index>=strLength)  
  134.         {  
  135.             throw Outofbond();  
  136.         }  
  137.         return p_str[index];  
  138.     }  
  139.      // = 赋值构造函数(判断是否是自身) 为什么要这样删除呢?  
  140.     MyString& MyString::operator=(const MyString& other)  
  141.     {  
  142.         if(this != &other)  
  143.         {  
  144.             if(strLength<other.strLength)  
  145.             {  
  146.                 delete[] p_str;  
  147.                 p_str = new char[other.strLength+1];  
  148.             }  
  149.             strLength = other.strLength;  
  150.             strcpy(p_str,other.p_str);  
  151.         }// 这样可能会产生多余的未释放的空间  
  152.         return *this;  
  153.     }  
  154.     // += 相当于返回的是备份的,内部对象的销毁,不影响的 和 下面的完全不一样的  
  155. //    MyString MyString::operator+=(const MyString& other)  
  156. //    {  
  157. //        if(NULL == other.p_str)  
  158. //        {  
  159. //            return *this;  
  160. //        }  
  161. //        MyString ret;  
  162. //        ret.strLength = strLength + other.strLength;  
  163. //        ret.p_str = new char[ret.strLength+1];  
  164. //        strcpy(ret.p_str,p_str);  
  165. //        strcat(ret.p_str,other.p_str);  
  166. //        return ret;  
  167. //    }  
  168.     // 返回的是当前对象的引用,当前对象就在调用函数里,所以不会销毁的  
  169.     // 判断一下是否是自身相加  
  170.     MyString& MyString::operator+=(const MyString& other)  
  171.     {  
  172.         if(NULL == other.p_str)  
  173.         {  
  174.             return *this;  
  175.         }  
  176.         if(this == &other)  
  177.         {  
  178.             MyString copy(*this);  
  179.             return *this += copy;  
  180.         }// 必须判断是否相等的,而且要+=的,这样相当于调用了自身,但是这次直接下面去了,不进入if的  
  181.         strLength += other.strLength;  
  182.         //strLength *= 2;  
  183.         char *p_old = p_str;  
  184.         p_str = new char[strLength+1];  
  185.         strcpy(p_str,p_old);  
  186.         strcat(p_str,other.p_str);  
  187.         delete[] p_old;// 删除旧的空间  
  188.         return *this;  
  189.     }  
  190.     // 成员操作函数  
  191.     // substr  返回应用是不行的,错误的;取从pos开始的n个字符组成的子串  
  192.     //MyString& MyString::substr(size_t pos,const size_t n)  
  193.     MyString MyString::substr(size_t pos,const size_t n)  
  194.     {  
  195.         if((pos+n)>=strLength)  
  196.         {  
  197.             throw Outofbond();  
  198.         }  
  199.         MyString ret;  
  200.         ret.strLength = n;  
  201.         //ret.p_str = new char[n+1];  
  202.         ret.p_str = new char[ret.strLength+1]; //也可以  
  203.         for(size_t i=0;i<n;i++)  
  204.         {  
  205.             ret.p_str[i] = p_str[pos+i];  
  206.         }  
  207.         ret.p_str[n] = '\0';  
  208. //        for(size_t i=0;i<ret.strLength;i++)  
  209. //        {  
  210. //            ret[i] = (*this)[pos+i];  
  211. //            cout << ret[i] << ",,";  
  212. //        }// 也行的,利用刚刚重载的【】,这样更好,不用再次判断越界了,不知道为什么,报错误的  
  213. //        ret[ret.strLength] = '\0';  
  214.         return ret;  
  215.     }  
  216.     // append 同 += 追加到末尾  
  217.     MyString& MyString::append(const MyString& other)  
  218.     {  
  219.         *this += other;// 利用刚刚那重载的+=  
  220.         return *this;  
  221.     }  
  222.     //insert 从pos开始的插入other  
  223.     MyString& MyString::insert(size_t pos,const MyString& other)  
  224.     {  
  225.         if(pos<0 || pos>=strLength)  
  226.         {  
  227.             throw Outofbond();  
  228.         }  
  229.         char *p_old = p_str;  
  230.         strLength += other.strLength;  
  231.         p_str = new char[strLength+1];  
  232.         for(size_t i=0;i<pos;i++)  
  233.         {  
  234.             *(p_str+i) = *(p_old+i);  
  235.         }  
  236.         for(size_t i=pos;i<other.strLength+pos;i++)  
  237.         {  
  238.             *(p_str+i) = other.p_str[i-pos];  
  239.         }  
  240.         for(size_t i=other.strLength+pos;i<strLength;i++)  
  241.         {  
  242.             *(p_str+i) = p_old[i-other.strLength];  
  243.         }  
  244.         *(p_str+strLength) = '\0';  
  245.         return *this;  
  246.     }  
  247.     //assign 替换  用other的POS开始的n对应替换this的pos开始的  
  248.     MyString& MyString::assign(MyString&other,size_t pos,size_t n)  
  249.     {  
  250. //        if(pos<0 || pos>=strLength)  
  251. //        {  
  252. //            throw Outofbond();  
  253. //        }  
  254.         assert(pos>0 && pos<strLength);// assert 的好处  
  255.         assert(pos+n<other.strLength);  
  256.         if(strLength < pos + n)  
  257.         {  
  258.             char *p_old = p_str;  
  259.             strLength = pos + n;  
  260.             p_str = new char[strLength+1];  
  261.             for(size_t i=0;i<pos;i++)  
  262.             {  
  263.                 *(p_str+i) = *(p_old+i);  
  264.             }  
  265.             delete[] p_old;  
  266.         }  
  267.         for(size_t i=pos;i<pos+n;i++)  
  268.         {  
  269.             *(p_str+i) = other.p_str[i];  
  270.         }  
  271.         *(p_str+pos+n) = '\0';  
  272.         return *this;  
  273.     }  
  274.     // erase 删除 这个方法并不是很好的,并没有释放所erase的空间,请看下面的  
  275. //    MyString& MyString::erase(size_t pos,size_t n)  
  276. //    {  
  277. //        if((pos+n)>strLength)  
  278. //        {  
  279. //            throw Outofbond();  
  280. //        }  
  281. //        size_t index = pos + n;  
  282. //        while(*(p_str+index)!='\0')  
  283. //        {  
  284. //            *(p_str+index-n) = *(p_str+index);  
  285. //            ++index;  
  286. //        }  
  287. //        *(p_str+index-n) = '\0';  
  288. //        return *this;  
  289. //    }  
  290.     // erase 删除 从pos开始的n个字符  
  291.     MyString& MyString::erase(size_t pos,size_t n)  
  292.     {  
  293.         if((pos+n)>strLength)  
  294.         {  
  295.             throw Outofbond();  
  296.         }  
  297.         char *p_old = p_str;  
  298.         strLength -= n;  
  299.         p_str = new char[strLength+1];  
  300.         for(size_t i=0;i<pos;i++)  
  301.         {  
  302.             p_str[i] = p_old[i];  
  303.         }  
  304.         for(size_t i=pos;i<strLength;i++)  
  305.         {  
  306.             p_str[i] = p_old[i+n];  
  307.         }  
  308.         *(p_str+strLength) = '\0';  
  309.         return *this;  
  310.     }  
  311.     //find_first_of 查找某一个字符 size_t 是非符号数的  
  312.     // 查找在字符串中第一个与str中的某个字符匹配的字符,返回它的位置。  
  313.     //搜索从index开始,如果没找到就返回string::npos  
  314.     int MyString::find_first_of(const char* str,size_t index)  
  315.     {  
  316.         if(NULL == str || index >=strLength)  
  317.             return npos;  
  318.         int tmp_len = strlen(str),j;  
  319.         size_t flag,min_index = INI_MAX;  
  320.         for(j=0;j<tmp_len;j++)  
  321.         {  
  322.             flag = npos;  
  323.             for(size_t i=index;i<strLength;i++)  
  324.             {  
  325.                 if(str[j] == p_str[i])  
  326.                 {  
  327.                     flag = i;  
  328.                     break;  
  329.                 }  
  330.             }  
  331. //            indexs[j] = flag;  
  332.             if(flag != npos)  
  333.             {  
  334.                 min_index = min_index<flag?min_index:flag;  
  335.             }  
  336.         }  
  337. //        for(j=0;j<tmp_len;j++)  
  338. //        {  
  339. //            if(indexs[j]!=npos)  
  340. //                min = min<indexs[j]?min:indexs[j];  
  341. //        }  
  342.         if(min_index == INI_MAX)  
  343.         {  
  344.             return npos;  
  345. //            min_index = npos;  
  346. //           cout << "---npos----" << min_index << ",,,,";  
  347.         }  
  348.         return min_index;  
  349.     }  
  350.     int MyString::find_first_of(const char ch,size_t index)  
  351.     {  
  352.         if(NULL == ch || index >=strLength)  
  353.             return npos;  
  354.         int j;  
  355.         size_t flag = npos;  
  356.         for(size_t i=index;i<strLength;i++)  
  357.         {  
  358.             if(ch == p_str[i])  
  359.             {  
  360.                 flag = i;  
  361.                 break;  
  362.             }  
  363.         }  
  364.         return flag;  
  365.     }  
  366.     int MyString::find_first_of(const MyString& str,size_t index)  
  367.     {  
  368.         if(NULL == str || index >=strLength)  
  369.             return npos;  
  370.         int j;  
  371.         size_t flag,min_index = INI_MAX;  
  372.         for(j=0;j<str.strLength;j++)  
  373.         {  
  374.             flag = npos;  
  375.             for(size_t i=index;i<strLength;i++)  
  376.             {  
  377.                 if(str[j] == p_str[i])  
  378.                 {  
  379.                     flag = i;  
  380.                     break;  
  381.                 }  
  382.             }  
  383.             if(flag != npos)  
  384.             {  
  385.                 min_index = min_index<flag?min_index:flag;  
  386.             }  
  387.         }  
  388.         if(min_index == INI_MAX)  
  389.         {  
  390.             return npos;  
  391.         }  
  392.         return min_index;  
  393.     }  
  394.     // 在字符串中查找第一个与str中的字符都不匹配的字符,返回它的位置。  
  395.     //搜索从index开始。如果没找到就返回string::nops O(N^2)  
  396.     int MyString::find_first_not_of(const char *str,size_t index)  
  397.     {  
  398.         if(NULL == str || index >=strLength)  
  399.             return npos;  
  400.         size_t i=0,j=0;  
  401.         size_t tmp_len = strlen(str);  
  402.         for(i=index;i<strLength;i++)  
  403.         {  
  404.             for(;j<tmp_len;j++)  
  405.             {  
  406.                 if(p_str[i]==str[j])  
  407.                     break;  
  408.             }  
  409.             if(j==tmp_len)  
  410.                 break;// 根据跳出的内层for的条件判断,找到即结束循环  
  411.         }  
  412.         if(i==strLength)  
  413.             return npos;// 未找到,// 根据跳出的内层for的条件判断,找到即结束循环  
  414.         return i;  
  415.     }  
  416.     int MyString::find_first_not_of(const MyString& str,size_t index)  
  417.     {  
  418.         if(NULL == str || index >=strLength)  
  419.             return npos;  
  420.         size_t i=0,j=0;  
  421.         for(i=index;i<strLength;i++)  
  422.         {  
  423.             for(;j<str.strLength;j++)  
  424.             {  
  425.                 if(p_str[i]==str[j])  
  426.                     break;// 如果相等 本轮i就无效了,进行下一轮  
  427.             }  
  428.             if(j==str.strLength)  
  429.                 break;// 根据跳出的内层for的条件判断,找到即结束循环  
  430.         }  
  431.         if(i==strLength)  
  432.             return npos;// 未找到,// 根据跳出的内层for的条件判断,找到即结束循环  
  433.         return i;  
  434.     }  
  435.     int MyString::find_first_not_of(const char ch,size_t index)  
  436.     {  
  437.         if(NULL == ch || index >=strLength)  
  438.             return npos;  
  439.         size_t i=0;  
  440.         for(i=index;i<strLength;i++)  
  441.         {  
  442.             if(p_str[i]!=ch)// 跟上面的略微不同,找一个不等就可以了  
  443.                 break;  
  444.         }  
  445.         if(i==strLength)  
  446.             return npos;// 未找到,// 根据跳出的内层for的条件判断,找到即结束循环  
  447.         return i;  
  448.     }  
  449.     // swap  都得变得,所以非const  
  450.     void MyString::swap(MyString& lhs,MyString& rhs)  
  451.     {  
  452.         lhs.strLength ^= rhs.strLength;  
  453.         rhs.strLength ^= lhs.strLength;  
  454.         lhs.strLength ^= rhs.strLength;  
  455.         char *p_tmp = rhs.p_str;  
  456.         rhs.p_str = lhs.p_str;  
  457.         lhs.p_str = p_tmp;  
  458.     }  
  459.     // replace_all  这个东西还是不太好弄的啊,不是很理想  
  460.     MyString& MyString::replace_all(const char oldc,const char newc)  
  461.     {  
  462.         if(NULL == oldc)  
  463.         {  
  464.             return *(this);  
  465.         }  
  466.         for(size_t i=0;i<strLength;i++)  
  467.         {  
  468.             if(p_str[i] == oldc)  
  469.             {  
  470.                 p_str[i] = newc;  
  471.             }  
  472.         }  
  473.         return *(this);  
  474.     }  
  475.     MyString& MyString::replace(size_t index,size_t num1,size_t num2,const char ch)  
  476.     {  
  477.   
  478.     }  
  479.     // find 函数  
  480.     int MyString::find(const char* str,size_t index)  
  481.     {  
  482.         assert(str!=NULL&&index<strLength);  
  483.         // kmp 中的getnext函数  
  484.         size_t len = strlen(str);  
  485.         size_t next[len+1];  
  486.         size_t j,k;  
  487.         next[0] = npos;  
  488.         j = 0;  
  489.         k = npos;  
  490.         while(j<len)  
  491.         {  
  492.             if(k==npos || str[j]==str[k])  
  493.             {  
  494.                 j++;  
  495.                 k++;  
  496.                 next[j] = k;  
  497.             }  
  498.             else  
  499.                 k = next[k];  
  500.         }  
  501.         // kmp 算法  
  502.         k = index;  
  503.         j = 0;  
  504.         while(p_str[k]!='\0')  
  505.         {  
  506.             if(j==0 || p_str[k]==str[j])  
  507.             {  
  508.                 k++;  
  509.                 j++;  
  510.             }  
  511.             else  
  512.             {  
  513.                 j = next[j];// 消除指针回溯  
  514.             }  
  515.             if(str[j] == '\0')//匹配成功  
  516.                 return k-j;  
  517.         }  
  518.         return npos;  
  519.     }  
  520.     int MyString::find(const MyString& str,size_t index)  
  521.     {  
  522. //        if(this == &str)  
  523. //        {  
  524. //            MyString other(*this);  
  525. //            find(other,index);  
  526. //        }  
  527.         assert(NULL!=str && index<strLength);  
  528.         // kmp 中的getnext函数  
  529.   
  530.         size_t next[str.strLength+2];  
  531.         size_t j,k;  
  532.         next[0] = npos;  
  533.         j = 0;  
  534.         k = npos;  
  535.         while(j<str.strLength)  
  536.         {  
  537.             if(k==npos || str.p_str[j]==str.p_str[k])  
  538.             {  
  539.                 j++;  
  540.                 k++;  
  541.                 next[j] = k;  
  542.             }  
  543.             else  
  544.                 k = next[k];  
  545.         }  
  546.         int i;  
  547.         for(i=1;i<=j;i++)  
  548.             cout << next[i] << ",";  
  549.         // kmp 算法  
  550.         k = index;  
  551.         j = 0;  
  552.         while(p_str[k]!='\0')  
  553.         {  
  554.             if(j==0 || p_str[k]==str.p_str[j])  
  555.             {  
  556.                 k++;  
  557.                 j++;  
  558.             }  
  559.             else  
  560.             {  
  561.                 j = next[j];// 消除指针回溯  
  562.             }  
  563.             if(str.p_str[j] == '\0')//匹配成功,不知道为什么调用自身的str[]重载总是报错的  
  564.                 return k-j;  
  565.         }  
  566.         if(str.p_str[j] == '\0')// 同一个字符串  
  567.             return k-j;  
  568.         return npos;  
  569.     }  
  570.     int MyString::find(const char ch,size_t index)  
  571.     {  
  572.         assert(NULL!=ch && index<strLength);  
  573.         for(size_t i=index;i<strLength;i++)  
  574.         {  
  575.             if(p_str[i] == ch)  
  576.                 return i;  
  577.         }  
  578.         return npos;  
  579.     }  


(3)测试函数main.cpp
  1. #include "MyString.h"  
  2. #include <iostream>  
  3. using namespace std;  
  4.   
  5. int main()  
  6. {  
  7.     int n;  
  8.     int choose = 1;  
  9.     int p,l;  
  10.     char cs[100];  
  11.     MyString s1;  
  12.     MyString s2("hello");  
  13.     MyString s3 = "HELLO";  
  14.     cout << "***** welcome *****\n";  
  15.     cout << "******* MADE BY zyp **********\n";  
  16.     cout << "s1= " << s1 << "s2= " << s2 << "s3= " << s3 << endl;  
  17.     cout << "请输入一个长度小于100的字符串:例如world\n";  
  18.     cin >> s1;  
  19.     s1 = s1;  
  20.     //s1 = s1+s1;  
  21.     s1 += s1;  
  22.     MyString s4(s1);  
  23.     s4.append(s1);  
  24.     s2.insert(2,s3);  
  25.     s1.erase(4,4);  
  26.     s1.assign(s2,1,7);  
  27.     cout << "s1= " << s1 << "s2= " << s2 << "s3= " << s3 << "s4= " << s4 << endl;  
  28.     s2 = s4.substr(2,7);  
  29.     cout << "s4[3]= " << s4[3] << s4.length() << (s1>=s2) << "s4.substr() " << s2 << endl;  
  30.     cout << "s1.find_first_of(beLE,2):" << s1.find_first_of("beLE",2) << ",s1.find_first_of(a,3):" << s1.find_first_of('a',3) << ",s1.find_first_of(s3,2):" << s1.find_first_of(s3,2) << endl;  
  31.     MyString s5(5,'b');  
  32.     s5 += s5;  
  33.     //s5.append(s5);// 不知道为什就是不能append  
  34.     cout << "s5 = " << s5 << "s5.find_first_not_of(aeHLEOl,2):" << s5.find_first_not_of("aeHLEOl",2) << "s5.find_first_not_of(aeHLEOl,0):" << s5.find_first_not_of("aeHLEOl") << endl;  
  35.     cout << "s5.find_first_not_of(s1,2):" << s5.find_first_not_of(s1,2) << "s5.find_first_not_of(b,2):" << s5.find_first_not_of('b',2) << endl;  
  36.     swap(s1,s5);  
  37.     s5.replace_all('a','J');  
  38.     MyString s6("LLO");  
  39.     cout << s1 << "," << s5 << "s5.find(LLO,0) " << s5.find("LLO",0) << "s5.find(s6,0) " << s5.find(s5) << endl;  
  40.     cout << npos << endl;  
  41.     return 0;  
  42. }  


三:感悟

(1)耗时将近2天的实现了它,自己与其从中学到了很多,倒不如说是重新认识了string类;

(2)自己知道这个简单的string类,距离string源代码还差的很远很远;但是它帮助我更好的理解了string类,至少会简单的应用了。

(3)简单的实现了一下string类,参照的是STL源码,但是自己理解的还是不够深,难免有一些错误,请各位指教,万分感谢!

(4)下一步进军list
评论 3
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

隨意的風

如果你觉得有帮助,期待你的打赏

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值