【c++篇】：模拟实现string类--探索字符串操纵的底层逻辑

✨感谢您阅读本篇文章，文章内容是个人学习条记的整理，如果那里有误的话还请您指正噢✨
✨ 个人主页：余辉zmh–CSDN博客
✨文章所属专栏：c++篇–CSDN博客
  

媒介

在上一篇文章中，我们相识到了std::string类的常用接口函数以及怎样纯熟使用。在这片文章中，我们将深入探究怎样模拟实现一个根本的string类。我们的目的不是创建一个功能完备的string库，而是通过这个过程来学习字符串处理惩罚的根本原理和常见的实现本事。通过模拟实现string类，我们不但可以或许深入明确字符串的内部工作原理，还能锻炼我们的编程本事，进步办理题目的本事，盼望这篇文章能过为你的编程之旅提供有代价的参考和开导。
   留意：模拟实现string类必要用到三个文件
  

• test.cpp文件用来举行测试
  
• string.cpp文件用来界说接口函数(部分较为短小的函数将会直接在string.h文件中界说)
  
• string.h文件用来声明头文件和string类
  

  一.string类的默认成员函数以及深拷贝

1.根本框架

为了和库内里的std::string类举行区分，我们起首界说一个定名空间Mystring用来封装我们本身模拟实现的string类。
根本框架如下：

1. namespace Mystring{
2.     class string{
3.     Public:
4.         static const size_t npos=-1;
5.         //成员函数
6.         
7.     private:
8.         //成员变量
9.         char* _str;
10.         size_t _size;
11.         size_t capacity;
12.     };
13. }

复制代码

• _str在堆上开发动态内存用来存储string对象的数据。
  
• _size用来纪录string对象的实际巨细。
  
• _capacity用来纪录当前string对象可存储的最大容量。
  
• npos是一个无符号整形的最大值，在查找等干系函数会用到。
  

2.默认成员函数

前面我们知道，一个类中有六个默认成员函数（在我之前的文章类和对象（二）中有关于默认成员函数的具体解说，不清晰的可以看我之前的文章），在模拟实现string类时，我们只必要实现常用的四个（构造函数，析构函数，拷贝构造函数，赋值运算符重载）即可。
1.构造函数

• 代码实现：
  
  1. //string.h中声明
  2. string(const char* str = "");
  3. //string.cpp中定义
  4. Mystring::string::string(const char* str)
  5. :_size(strlen(str))
  6. ,_capacity(_size)
  7. ,_str(new char[_size+1])
  8. {
  9.     memcpy(_str,str,_size+1);
  10. }

  复制代码
• 实现原理：
  
  
  
  • str字符串作为常量参数用来创建string对象，缺省值为空字符串（当没有参数时就是创建一个空对象），缺省值要在声明中给，不能再界说中给。
    
  • _size字符串巨细和_capacity容量初始化值为参数str字符串的巨细(strlen(str))。
    
  • _str指针用来指向存储string对象的动态内存，开发空间的巨细为参数str字符串的巨细加一，加一是为了存放末了的’\0’，开发空间后要将str字符串内容拷贝到开发的动态内存。
    
  
  

2.析构函数

• 代码实现：
  
  1. //string.h文件中声明
  2. ~string();
  3. //string.cpp文件中定义
  4. Mystring::string::~string()
  5. {
  6.     delete[] _str;
  7.     _str=nullptr;
  8.     _size=0;
  9.     _capacity=0;
  10. }

  复制代码
• 实现原理：
  
  
  
  • 开释动态内存空间，再将_str指针置为空指针。
    
  • _size字符串巨细和_capacity容量置为0。
    
  
  

3.拷贝构造函数（深拷贝）

• 代码实现：
  
  1. //string.h文件中声明
  2. string(const string&s);
  3. //string.cpp文件中定义
  4. Mystring::string::string(const string&s)
  5. {
  6.     _str=new char[s._capacity+1];
  7.     strcpy(_str,s._str);
  8.     _size=s._size;
  9.     _capacity=s._capacity;
  10. }

  复制代码
• 实现原理：
  
  
  
  • 用一个string对象拷贝构造一个新的string对象，拷贝构造函数必要完成深拷贝。
    
  • 先用字符串s的容量作为新空间的巨细申请一个新的动态内存空间，再将s字符串的数据拷贝到新的内存空间中。
    
  • 新的string对象的_size和_capacity分别是原string对象的_size和_capacity.
    
  
  

4.赋值运算符重载（深拷贝）

• 代码实现：
  
  1. //string.h文件中声明
  2. string& operator=(const string&s);
  3. //string.cpp文件中定义
  4. Mystring::string& Mystring::string::operator=(const string&s)
  5. {
  6.     char* tmp=new char[s._capacity+1];
  7.     memcpy(tmp,s._str,s._size+1);
  8.     delete[] _str;
  9.     _str=tmp;
  10.     _capacity=s._capacity;
  11.     _size=s._size;
  12.     return *this;
  13. }

  复制代码
• 实现原理：
  
  
  
  • 赋值和拷贝构造的差别点在于，拷贝构造是用已有的对象拷贝构造一个新的对象；而赋值是用一个已存在的对象赋值给另一个已存在的对象，赋值也是必要完成深拷贝。
    
  • 先用赋值对象s的容量巨细申请一个新的动态内存空间，设置一个新的tmp指针先指向这块空间，再将赋值对象s的数据拷贝到新的内存空间中。
    
  • 开释被赋值对象的原有空间，再将被赋值对象的_str指针指向新的内存空间。
    
  • 被赋值对象的_size和_capacity分别是赋值对象s的_size和_capacity.
    
  
  

3.什么是深拷贝

深拷贝（Deep Copy）是对象复制操纵中的一种，它不但仅复制对象的表层数据（如指针或引用），还会递归地复制对象内部全部动态分配的内存、引用的其他对象或其他资源。如许，复制出来的新对象与原始对象在内存中是完全独立的，对它们的修改不会影响到相互。
深拷贝的须要性

当对象包罗指向动态分配内存的指针或其他必要管理的资源时，浅拷贝（仅复制指针值）会导致两个对象共享同一块内存。这大概会引发以下题目：
   

• 数据破坏：一个对象修改了它共享的内存中的数据，导致另一个对象看到的数据也发生了变革。
  
• 内存走漏：如果两个对象都以为本身拥有这块内存，并在析构时实行开释它，就会导致重复开释内存的错误（double free），进而大概导致步调瓦解。
  
• 资源管理杂乱：如果对象还管理其他资源（如文件句柄、网络毗连等），共享这些资源大概会导致资源被不测关闭或重复访问。
  

  深拷贝的实现

实现深拷贝通常涉及以下几个步调：
   

• 为新对象分配内存：如果原始对象包罗动态分配的内存，深拷贝的第一步是为新对象分配相应的内存空间。
  
• 复制数据：将原始对象中的数据复制到新分配的内存中。如果数据本身也是对象（即对象包罗指向其他对象的指针），则必要递归地应用深拷贝。
  
• 更新指针：将新对象的指针成员指向新分配的内存，而不是原始对象的内存。
  
• 处理惩罚其他资源：如果对象管理其他资源（如文件、网络毗连等），则必要确保新对象也能精确地获取或创建这些资源的副本。
  

  4.测试

测试代码如下：

1. void test1(){
2.     //创建s1对象
3.     Mystring::string s1("hello world");
4.     //用s1对象拷贝构造s2对象
5.     Mystring::string s2(s1);
6.     //将s1对象赋值给s3对象
7.     Mystring::string s3("hello");
8.     s3=s1;
9. }

复制代码

测试效果如下：

二.string类的访问和迭代器干系函数

1.访问干系函数

• at()函数代码实现：
  
  1. //string文件中声明和定义
  2. char& at(size_t pos)
  3. {
  4.     //断言检查pos是否符合字符串的范围
  5.     assert(pos<_size);
  6.     //直接返回字符数组对应下标上的字符即可
  7.     return _str[pos];
  8. }

  复制代码
• operator[]函数代码实现：
  
  1. //string文件中声明和定义
  2. //和at()函数同理
  3. char& operator[](size_t pos)
  4. {
  5.     assert(pos<_size);
  6.     return _str[pos];
  7. }

  复制代码

2.迭代器干系函数

1.平常string对象的迭代器

• 范例界说：
  
  1. //普通string对象的迭代器类型
  2. typedef char* iterator;

  复制代码
• begin()函数代码实现：
  
  1. //string文件中声明和定义
  2. iterator begin()const
  3. {
  4.     //返回_str首元素的地址
  5.      return _str;
  6. }

  复制代码
• end()函数代码实现：
  
  1. //string文件中声明和定义
  2. iterator end()const
  3. {
  4.     //返回_str最后一个元素的下一个位置的地址
  5.     return _str+_size;
  6. }

  复制代码

2.const string对象的迭代器

• 范例界说：
  
  1. //const string对象的迭代器类型
  2. typedef const char* const_iterator;

  复制代码
• cbegin()函数代码实现：
  
  1. //string文件中声明和定义
  2. const_iterator begin()const
  3. {
  4.     //返回_str首元素的地址
  5.      return _str;
  6. }

  复制代码
• cend()函数代码实现：
  
  1. //string文件中声明和定义
  2. const_iterator end()const
  3. {
  4.     //返回_str最后一个元素的下一个位置的地址
  5.     return _str+_size;
  6. }

  复制代码

3.测试

测试代码如下：

1. void test2(){
2.     Mystring::string s1("hello world");
3.     //使用opreator[]打印s1
4.     for(size_t i=0;i<s1.size();i++){
5.         cout<<s1[i]<<" ";
6.     }
7.     cout<<endl;
9.     //使用普通对象的迭代器打印s1
10.     Mystring::string::iterator it=s1.begin();
11.     while(it!=s1.end()){
12.         cout<<*it<<" ";
13.         it++;
14.     }
15.     cout<<endl;
17.     //使用const对象的迭代器打印s2
18.     const Mystring::string s2("hello");
19.     Mystring::string::const_iterator rit=s2.begin();
20.     while(rit!=s2.end()){
21.         cout<<*rit<<" ";
22.         rit++;
23.     }
24.     cout<<endl;
25. }

复制代码

测试效果如下：

三.string类的容量干系函数

1.容量巨细干系函数

获取string对象的巨细必要使用size()函数，获取容量则必要使用capacity()函数

• size()函数代码实现:
  
  1. //string.h文件中声明和定义
  2. //直接返回_size即可
  3. size_t size()
  4. {
  5.     return _size;
  6. }

  复制代码
• capacity()函数代码实现：
  
  1. //string.h文件中声明和定义
  2. //直接返回_capacity即可
  3. size_t capacity()
  4. {
  5.     return _capacity;
  6. }        

  复制代码

2.扩容干系函数

string类扩容干系的函数紧张是reserve()和resize()。

• reserve()函数代码实现：
  
  1. //string.h文件中声明
  2. void reserve(size_t);
  3. //string.cpp文件中定义
  4. void Mystring::string::reserve(size_t n)
  5. {
  6.     if(n>_capacity){
  7.         char*tmp=new char[n+1];
  8.         memcpy(tmp,_str,_size+1);
  9.         delete[] _str;
  10.         _str=tmp;
  11.         _capacity=n;
  12.     }
  13. }

  复制代码
• 实现原理：
  
  
  
  • 起首判定必要扩容的巨细n是否大于原容量巨细_capacity，如果小于则不举行扩容，大于时就必要扩容。
    
  • 扩容时先开发内存巨细为(n+1)的动态内存空间，在设置一个新的字符指针tmp指向新的内存空间，然后将原string对象的数据拷贝到新的内存空间中。
    
  • 开释原string对象的_str指针，再重新指向开发的新内存空间，末了更改内存巨细为n。
    
  
  
• resize()函数代码实现：
  
  1. //string.h文件中声明
  2. void resize(size_t n,char ch='\0');
  3. //string.cpp文件中定义
  4. void Mystring::string::resize(size_t n,char ch)
  5. {
  6.     if(n>_capacity){
  7.         reserve(n);
  8.     }
  9.     if(n>_size){
  10.         for(size_t i=_size;i<n;i++){
  11.             _str[i]=ch;
  12.         }
  13.     }
  14.     _size=n;
  15.     _str[_size]='\0';
  17. }

  复制代码
• 实现原理：
  
  
  
  • 起首依然是必要判定扩容的巨细n是否大于原容量巨细_capacity，和reserve()函数差别的是，resize对于扩容巨细n小于原容量巨细时会发生截断，大于时就会举行扩容操纵，这里扩容操纵直接调用reserve()函数即可。
    
  • 如果扩容巨细n大于原string对象的_size，必要将多余的空间初始化为参数ch，参数ch的缺省值设置为’\0’（要在声明中给），没有传参时，默认初始化为0。
    
  
  

3.测试

测试代码如下：

1. void test3(){
2.     Mystring::string s1("hello world");
3.     cout<<s1.size()<<" "<<s1.capacity()<<endl;
4.     //s1容量扩为15
5.     s1.reserve(15);
6.     cout<<s1.size()<<" "<<s1.capacity()<<endl;
7.     //s1容量扩为20，多余空间用字符a填充
8.     s1.resize(20,'a');
9.     cout<<s1.size()<<" "<<s1.capacity()<<endl;
10.     cout<<s1<<endl;
11.     //s1缩容为8，发生截断
12.     s1.resize(8);
13.     cout<<s1.size()<<" "<<s1.capacity()<<endl;
14.     cout<<s1<<endl;
15. }

复制代码

测设效果如下：

四.string类的修改干系函数

1.拼接操纵干系函数

• 1.push_back()函数实现：
  
  1. //string.h文件中声明
  2. void push_back(char ch);
  3. //string.cpp文件中定义
  4. void Mystring::string::push_back(char ch)
  5. {
  6.     if(_size==_capacity){
  7.         reserve(_capacity==0?4:2*_capacity);
  8.     }
  9.     _str[_size]=ch;
  10.     _size++;
  11.     _str[_size]='\0';
  12. }

  复制代码
  2.实现原理：
  
  
  
  • push_back()函数的功能是尾插单个字符，在尾插之前要先判定是否必要扩容，在扩容时，如果必要尾插的string对象是空对象扩容 巨细先设置为4，如果不是空对象则扩容巨细是原容量的二倍，扩容直接调用reserve()函数即可。
    
  • 插入时，将原来字符串的’\0’位置存放插入的字符ch，再将巨细_size增长一，末了重新在字符串的末了加上’\0’。
    
  
  
• 1.append()函数实现：
  append()函数有两种差别的实现，一个是在原string对象后增长单个字符，一个是增长字符串。
  
  1. //string.h文件中声明
  2. void append(char ch);               
  3. void append(const char* str);  
  4. //string.cpp文件中定义
  5. //增加单个字符
  6. void Mystring::string::append(char ch)
  7. {
  8.     push_back(ch);
  9. }
  10. //增加字符串
  11. void Mystring::string::append(const char* str)
  12. {
  13.     size_t len=strlen(str);
  14.     if(_size+len>_capacity){
  15.         reserve(_size+len);
  16.     }
  17.     //_str加上_size就是原字符串结尾的位置，插入的字符串拷贝到原字符串后面
  18.     memcpy(_str+_size,str,len+1);
  19.     _size+=len;
  20. }

  复制代码
  2.实现原理：
  
  
  
  • 增长单个字符直接调用push_back函数。
    
  • 增长字符串时，先获取插入字符串的巨细len，然后判定原字符串的巨细加上插入字符串的巨细是否大于容量_capacity，如果大于必要先举行扩容，扩容巨细为原字符串的巨细加上插入字符串的巨细。
    
  • 将插入的字符串拷贝到原字符串反面，拷贝巨细为len+1，然后修改_size值。
    
  
  
• 1.operator+=函数实现：
  operator+=函数和append()函数一样有两种差别的实现，在原string对象后增长单个字符和字符串。
  
  1. //string.h文件中声明
  2. string& operator+=(char ch);         
  3. string& operator+=(const char* str);
  4. //string.cpp文件中定义
  5. //增加单个字符
  6. Mystring::string& Mystring::string::operator+=(char ch)
  7. {
  8.     push_back(ch);
  9.     return *this;
  10. }
  11. //增加字符串
  12. Mystring::string& Mystring::string::operator+=(const char* str)
  13. {
  14.    append(str);
  15.     return *this;
  16. }

  复制代码
  2.实现原理：
  
  
  
  • 增长单个字符直接调用push_back()函数，末了要返回this指针。
    
  • 增长字符串直接调用append(const char* str)函数，末了返回this指针。
    
  
  

2.插入操纵干系函数

• insert()函数实现：
  1.插入n个字符：
  
  1. //string.h文件中声明
  2. void insert(size_t pos,size_t n,char ch);
  3. //string.cpp文件中定义
  4. void Mystring::string::insert(size_t pos,size_t n,char ch)
  5. {
  6.     assert(pos<_size);
  7.     if((_size+n)>_capacity){
  8.         reserve(_size+n);
  9.     }
  10.     size_t end=_size;
  11.     while(end>=pos&&end!=npos){
  12.         _str[end+n]=_str[end];
  13.         end--;
  14.     }
  15.     for(size_t i=0;i<n;i++){
  16.         _str[pos+i]=ch;
  17.     }
  18.     _size+=n;
  20. }

  复制代码
  实现原理：
  
  
  
  • 如果原字符串巨细加上插入的个数大于容量巨细时，必要先举行扩容，扩容巨细为原字符串巨细加上插入的个数。
    
  • 将插入位置反面的数据依次今后移动n个位置。
    
  • 再将移动后空出来的位置插入n个字符ch。末了修改_size巨细。
    
  2.插入字符串：
  
  1. //string.h文件中声明
  2. void insert(size_t pos,const char*str);
  3. //string.cpp文件中定义
  4. void Mystring::string::insert(size_t pos,const char*str)
  5. {
  6.     assert(pos<_size);
  7.     size_t len=strlen(str);
  8.     if(_size+len>_capacity){
  9.         reserve(_size+len);
  10.     }
  11.     size_t end=_size;
  12.     while(end>=pos&&end!=npos){
  13.         _str[end+len]=_str[end];
  14.         end--;
  15.     }
  16.     for(size_t i=0;i<len;i++){
  17.         _str[pos+i]=str[i];
  18.     }
  19.     _size+=len;
  20. }

  复制代码
  实现原理：
     
  
  
  
  • 插入字符串和插入n个字符原理类似，差别点是，末了插入时，必要依次插入字符串的字符。
    
  
  

3.删除操纵干系函数

• erase()函数实现：
  
  1. //string.h中声明
  2. void erase(size_t pos,size_t len=npos);
  3. //string.cpp文件中定义
  4. void Mystring::string::erase(size_t pos,size_t len)
  5. {
  6.     assert(pos<_size);
  7.     if(len==npos||pos+len>=_size){
  8.         _size=pos;
  9.         _str[_size]='\0';
  10.     }
  11.     else{
  12.         size_t end=len+pos;
  13.         while(end<=_size){
  14.             _str[pos++]=_str[end++];
  15.         }
  16.         _size-=len;
  17.     }
  18. }

  复制代码
• 实现原理：
  
  
  
  • 删除要分为两种情况，第一种，如果删除的个数大于_size大概len即是npos值，直接从pos位置将反面全部删除。
    
  • 第二种，依次将反面的字符往前移动，从而到达删除的目的。
    
  
  

4.测试

测试代码如下：

1. void test4(){
2.     //创建一个空对象s1
3.     Mystring::string s1;
4.     //s1追加字符串hello
5.     s1.append("hello");
6.     cout<<s1<<endl;
7.     //s1追加字符串world
8.     s1+="world";
9.     cout<<s1<<endl;
10.     //s1尾插字符！
11.     s1.push_back('!');
12.     cout<<s1<<endl;
13.     //在s1下标为6的位置插入***
14.     s1.insert(6,"***");
15.     cout<<s1<<endl;
16.     //删除s1下标为10后面的所有字符
17.     s1.erase(10);
18.     cout<<s1<<endl;
19.     //删除s1下标为5后面的三个字符
20.     s1.erase(5,3);
21.     cout<<s1<<endl;
22. }

复制代码

测试效果如下：

五.string类的流插入和流提取函数

• 1.operator<<流插入函数实现：
  
  1. //string.h文件中声明
  2. ostream& operator<<(ostream& out,const string&s);
  3. //string.cpp文件中定义
  4. ostream& Mystring::operator<<(ostream& out,const string&s)
  5. {
  6.     cout<<"operator<<"<<endl;
  7.     for(auto e:s){
  8.         out<<e;
  9.     }
  10.     return out;
  11. }

  复制代码
• 1.operator>>流提取函数实现：
  
  1. //string.h文件中声明
  2. istream& operator>>(istream &in,string &s);
  3. //string.cpp文件中定义
  4. istream& Mystring::operator>>(istream &in, string &s)
  5. {
  6.     cout<<"operator>>"<<endl;
  7.     s.clear();
  8.     char ch = in.get();
  9.         // 处理前缓冲区前面的空格或者换行
  10.         while (ch == ' ' || ch == '\n')
  11.         {
  12.                 ch = in.get();
  13.         }
  14.         char buff[128];
  15.         int i = 0;
  16.         while (ch != ' ' && ch != '\n')
  17.         {
  18.                 buff[i++] = ch;
  19.                 if (i == 127)
  20.                 {
  21.                         buff[i] = '\0';
  22.                         s += buff;
  23.                         i = 0;
  24.                 }
  25.                 ch = in.get();
  26.         }
  27.         if (i != 0)
  28.         {
  29.                 buff[i] = '\0';
  30.                 s += buff;
  31.         }
  32.         return in;
  33. }

  复制代码

测试代码如下：

1. void test5(){
2.     Mystring::string s1;
3.     //输入
4.     cin>>s1;
5.     //输出
6.     cout<<s1<<endl;
7. }

复制代码

六.string类完备代码

1.string.h头文件代码

1. #include<iostream>
2. #include<string>
3. #include<string.h>
4. #include<assert.h>
5. using namespace std;
7. namespace Mystring{
8.     class string{
9.     public:
10.         static const size_t npos=-1;
11.         //构造函数
12.         string(const char* str = "");
13.         //析构函数
14.         ~string();
15.         //拷贝构造函数
16.         string(const string&s);
17.         //赋值运算符重载
18.         string& operator=(const string&s);
19.         
20.         //c格式打印
21.         const char* c_str(){
22.             return _str;
23.         }
25.         //容量大小
26.         size_t size()
27.         {
28.             return _size;
29.         }
30.         size_t capacity()
31.         {
32.             return _capacity;
33.         }
34.         //扩容
35.         void reserve(size_t n);
36.         void resize(size_t n,char ch='\0');
38.         void clear(){
39.             _size=0;
40.             _str[_size]='\0';
41.         }
43.         //访问方式
44.         char& operator[](size_t pos){
45.             assert(pos<_size);
46.             return _str[pos];
47.         }
48.         char& at(size_t pos){
49.             assert(pos<_size);
50.             return _str[pos];
51.         }
53.         //迭代器
54.         typedef char* iterator;
55.         iterator begin() {
56.             return _str;
57.         }
58.         iterator end() {
59.             return _str+_size;
60.         }
61.         typedef const char* const_iterator;
62.         const_iterator begin()const {
63.             return _str;
64.         }
65.         const_iterator end()const {
66.             return _str+_size;
67.         }
69.         //修改
70.         void push_back(char ch);            
71.         void append(char ch);               
72.         void append(const char* str);        
73.         string& operator+=(char ch);         
74.         string& operator+=(const char* str);
75.         void insert(size_t pos,size_t n,char ch);
76.         void insert(size_t pos,const char*str);
77.         void erase(size_t pos,size_t len=npos);
79.         //查找
80.         size_t find(char ch,size_t pos=0);
81.         size_t find(const char*str,size_t pos=0);
83.         //友元函数
84.         friend ostream& operator<<(ostream& out,const string&s);
85.         friend istream& operator>>(istream& in,string&s);
87.     private:
88.         int _size;
89.         int _capacity;
90.         char* _str;
91.     };
93.     //非string成员函数
94.     ostream& operator<<(ostream& out,const string&s);
95.     istream& operator>>(istream& in,string&s);
96. }

复制代码

2.string.cpp函数界说文件代码

1. #include"string.h"
3. Mystring::string::string(const char* str)
4. :_size(strlen(str))
5. ,_capacity(_size)
6. ,_str(new char[_size+1])
7. {
8.     cout<<"string()"<<endl;
9.     memcpy(_str,str,_size+1);
10. }
12. Mystring::string& Mystring::string::operator=(const string&s)
13. {
14.     cout<<"operator="<<endl;
15.     char* tmp=new char[s._capacity+1];
16.     memcpy(tmp,s._str,s._size+1);
17.     delete[] _str;
18.     _str=tmp;
19.     _capacity=s._capacity;
20.     _size=s._size;
21.     return *this;
22. }
24. Mystring::string::~string()
25. {
26.     cout<<"~string()"<<endl;
27.     delete[] _str;
28.     _str=nullptr;
29.     _size=0;
30.     _capacity=0;
31. }
33. Mystring::string::string(const string&s)
34. {
35.     cout<<"string()"<<endl;
36.     _str=new char[s._capacity+1];
37.     strcpy(_str,s._str);
38.     _size=s._size;
39.     _capacity=s._capacity;
40. }
42. void Mystring::string::reserve(size_t n)
43. {
44.     if(n>_capacity){
45.         char*tmp=new char[n+1];
46.         memcpy(tmp,_str,_size+1);
47.         delete[] _str;
48.         _str=tmp;
49.         _capacity=n;
50.     }
51. }
53. void Mystring::string::resize(size_t n,char ch)
54. {
55.     if(n>_capacity){
56.         reserve(n);
57.     }
58.     if(n>_size){
59.         for(size_t i=_size;i<n;i++){
60.             _str[i]=ch;
61.         }
62.     }
63.     _size=n;
64.     _str[_size]='\0';
66. }
68. void Mystring::string::push_back(char ch)
69. {
70.     if(_size==_capacity){
71.         reserve(_capacity==0?4:2*_capacity);
72.     }
73.     _str[_size]=ch;
74.     _size++;
75.     _str[_size]='\0';
76. }
78. void Mystring::string::append(char ch)
79. {
80.     push_back(ch);
81. }
83. void Mystring::string::append(const char* str)
84. {
85.     size_t len=strlen(str);
86.     if(_size+len>_capacity){
87.         reserve(_size+len);
88.     }
89.     memcpy(_str+_size,str,len+1);
90.     _size+=len;
91. }
93. Mystring::string& Mystring::string::operator+=(char ch)
94. {
95.     push_back(ch);
96.     return *this;
97. }
99. Mystring::string& Mystring::string::operator+=(const char* str)
100. {
101.    append(str);
102.     return *this;
103. }
105. size_t Mystring::string::find(char ch,size_t pos)
106. {
107.     assert(pos<_size);
108.     for(size_t i=pos;i<_size;i++){
109.         if(_str[i]==ch){
110.             return i;
111.         }
112.     }
113.     return npos;
114. }
116. size_t Mystring::string::find(const char*str,size_t pos)
117. {
118.     assert(pos<_size);
119.     const char* ptr=strstr(_str+pos,str);
120.     if(ptr){
121.         return ptr-_str;
122.     }
123.     else{
124.         return npos;
125.     }
126. }
128. void Mystring::string::insert(size_t pos,size_t n,char ch)
129. {
130.     assert(pos<_size);
131.     if((_size+n)>_capacity){
132.         reserve(_size+n);
133.     }
134.     size_t end=_size;
135.     while(end>=pos&&end!=npos){
136.         _str[end+n]=_str[end];
137.         end--;
138.     }
139.     for(size_t i=0;i<n;i++){
140.         _str[pos+i]=ch;
141.     }
142.     _size+=n;
144. }
146. void Mystring::string::insert(size_t pos,const char*str)
147. {
148.     assert(pos<_size);
149.     size_t len=strlen(str);
150.     if(_size+len>_capacity){
151.         reserve(_size+len);
152.     }
153.     size_t end=_size;
154.     while(end>=pos&&end!=npos){
155.         _str[end+len]=_str[end];
156.         end--;
157.     }
158.     for(size_t i=0;i<len;i++){
159.         _str[pos+i]=str[i];
160.     }
161.     _size+=len;
162. }
164. void Mystring::string::erase(size_t pos,size_t len)
165. {
166.     assert(pos<_size);
167.     if(len==npos||pos+len>=_size){
168.         _size=pos;
169.         _str[_size]='\0';
170.     }
171.     else{
172.         size_t end=len+pos;
173.         while(end<=_size){
174.             _str[pos++]=_str[end++];
175.         }
176.         _size-=len;
177.     }
178. }
180. ostream& Mystring::operator<<(ostream& out,const string&s)
181. {
182.     //cout<<"operator<<"<<endl;
183.     for(auto e:s){
184.         out<<e;
185.     }
186.     return out;
187. }
189. istream& Mystring::operator>>(istream &in, string &s)
190. {
191.     cout<<"operator>>"<<endl;
192.     s.clear();
193.     char ch = in.get();
194.         // 处理前缓冲区前面的空格或者换行
195.         while (ch == ' ' || ch == '\n')
196.         {
197.                 ch = in.get();
198.         }
199.         char buff[128];
200.         int i = 0;
201.         while (ch != ' ' && ch != '\n')
202.         {
203.                 buff[i++] = ch;
204.                 if (i == 127)
205.                 {
206.                         buff[i] = '\0';
207.                         s += buff;
208.                         i = 0;
209.                 }
210.                 ch = in.get();
211.         }
212.         if (i != 0)
213.         {
214.                 buff[i] = '\0';
215.                 s += buff;
216.         }
217.         return in;
218. }

复制代码

3.test.cpp测试文件代码

1. #include"string.h"void test1(){
2.     //创建s1对象
3.     Mystring::string s1("hello world");
4.     //用s1对象拷贝构造s2对象
5.     Mystring::string s2(s1);
6.     //将s1对象赋值给s3对象
7.     Mystring::string s3("hello");
8.     s3=s1;
9. }
10. void test2(){
11.     Mystring::string s1("hello world");
12.     //使用opreator[]打印s1
13.     for(size_t i=0;i<s1.size();i++){
14.         cout<<s1[i]<<" ";
15.     }
16.     cout<<endl;
18.     //使用普通对象的迭代器打印s1
19.     Mystring::string::iterator it=s1.begin();
20.     while(it!=s1.end()){
21.         cout<<*it<<" ";
22.         it++;
23.     }
24.     cout<<endl;
26.     //使用const对象的迭代器打印s2
27.     const Mystring::string s2("hello");
28.     Mystring::string::const_iterator rit=s2.begin();
29.     while(rit!=s2.end()){
30.         cout<<*rit<<" ";
31.         rit++;
32.     }
33.     cout<<endl;
34. }
35. void test3(){
36.     Mystring::string s1("hello world");
37.     cout<<s1.size()<<" "<<s1.capacity()<<endl;
38.     //s1容量扩为15
39.     s1.reserve(15);
40.     cout<<s1.size()<<" "<<s1.capacity()<<endl;
41.     //s1容量扩为20，多余空间用字符a填充
42.     s1.resize(20,'a');
43.     cout<<s1.size()<<" "<<s1.capacity()<<endl;
44.     cout<<s1<<endl;
45.     //s1缩容为8，发生截断
46.     s1.resize(8);
47.     cout<<s1.size()<<" "<<s1.capacity()<<endl;
48.     cout<<s1<<endl;
49. }
50. void test4(){
51.     //创建一个空对象s1
52.     Mystring::string s1;
53.     //s1追加字符串hello
54.     s1.append("hello");
55.     cout<<s1<<endl;
56.     //s1追加字符串world
57.     s1+="world";
58.     cout<<s1<<endl;
59.     //s1尾插字符！
60.     s1.push_back('!');
61.     cout<<s1<<endl;
62.     //在s1下标为6的位置插入***
63.     s1.insert(6,"***");
64.     cout<<s1<<endl;
65.     //删除s1下标为10后面的所有字符
66.     s1.erase(10);
67.     cout<<s1<<endl;
68.     //删除s1下标为5后面的三个字符
69.     s1.erase(5,3);
70.     cout<<s1<<endl;
71. }
72. void test5(){
73.     Mystring::string s1;
74.     //输入
75.     cin>>s1;
76.     //输出
77.     cout<<s1<<endl;
78. }
79. int main(){   //test1();   //test2();   //test3();   //test4();   test5();   return 0;}

复制代码

以上就是关于怎样模拟实现string类的解说，如果那里有错的话，可以在批评区指正，也接待各人一起讨论学习，如果对你的学习有资助的话，点点赞关注支持一下吧！！！