【C++】：string类底层的模拟实现

目录

• 引言
• 1，构造函数
• 2，析构函数
• 3，取出字符串的地址
• 4，计算有效数据个数
• 5，[ ]运算符重载
• 6，简单迭代器
• 7，预开空间(扩容)
• 8，尾插一个字符
• 9，尾插一个字符串
• 10，+=运算符重载
• 11，在pos位置插入字符/字符串
• • 11.1 在pos位置插入字符
  • 11.2 尾插一个字符串
  • 12，从pos位置开始删除长度为len的字符串
  • 13，从pos位置开始查找字符/字符串
  • • 13.1 查找字符
    • 13.2 查找字符串
    • 14，拷贝构造(传统)
    • 15，=赋值拷贝(传统)
    • 16，交换函数swap
    • 17，从pos位置开始取len个字符的串
    • 18. 字符串的比较
    • 19，清除函数clear
    • 20，流插入，流提取
    • • 20.1 流插入
      • 20.2 流提取
      • 21，拷贝构造和赋值拷贝的现代写法(重点)
      • • 21.1 拷贝构造
        • 21.2 赋值拷贝

          引言

          点击跳转到文章：【string类的基本使用】

          上一篇文章已经对string类进行了简单的介绍，大家只要能够正常使用即可。

          这篇文章主要是对string类的一些重点接口函数进行模拟实现。本文依然采用多文件的方式，string.h放类的声明，string.cpp放成员函数的定义。

          string.h

          #pragma once#include #include #include using namespace std;//定义一个叫做bit的命名空间，隔离C++库里的string类 namespace bit{ class string { public: //typedef实现二次封装 //由于string类是连续的空间，所以可以定义为原生指针 typedef char* iterator; //const迭代器，指针指向的内容不能修改 typedef const char* const_iterator; //实现迭代器,一定要实现为begin 和end //迭代器屏蔽了底层细节，提供了一种简单通用的访问容器的方式 iterator begin(); iterator end(); const_iterator begin()const; const_iterator end()const;// string();//无参构造    //有参与无参构造用全缺省进行合并,在声明处给缺省值 string(const char* str = "");//传参构造 //析构函数 ~string(); //拷贝构造 string(const string& s); //赋值运算重载(传统) //string& operator=(const string& s); //赋值运算重载(现代) string& operator=(string tmp); const char* c_str() const; //用下标的方式遍历字符串 size_t size()const; char& operator[](size_t pos); const char& operator[](size_t pos)const; //用于扩容，一般不缩容 void reserve(size_t n); void push_back(char ch);//尾插一个字符 void append(const char* str);//尾插字符串 //用运算符重载实现尾插 string& operator+=(char ch); string& operator+=(const char* str); //在指定位置插入 字符或是字符串 void insert(size_t pos, char ch); void insert(size_t pos, const char* str); //在指定位置删除长度为len void erase(size_t pos = 0, size_t len = npos); //从pos位置开始找字符或是字符串 size_t find(char ch, size_t pos =0); size_t find(const char* str, size_t pos = 0); //交换函数 void swap(string& s); //从pos位置找一个子串 string substr(size_t pos = 0, size_t len = npos); //字符串的比较 bool operator(const string& s)const; bool operator=(const string& s)const; bool operator==(const string& s)const; bool operator!=(const string& s)const; //把当前数据清除，但是不清空间 void clear(); private:  //这里的缺省值时给现代写法的构造函数的 char* _str = nullptr; size_t _size = 0;//有效数据个数,指向最后一个有效数据的下一个位置\0 size_t _capacity = 0;//容量 //特例：静态成员变量只有无符号整形才可以在声明时给缺省值 //const static size_t npos = -1;//ok //const static double d = 2.2;//err const static size_t npos; }; //流插入，流提取  //不适合写成成员函数，涉及第一个参数的位置问题 istream& operator>> (istream& is, string& str); ostream& operator    //_str = nullptr;//err 防止对空指针的解引用    _str = new char[_size + 1];//多开一个是给\0的_capacity = _size;strcpy(_str, str);//把初始化内容拷贝进空间}delete[] _str;//析构销毁资源_str = nullptr;//置空_size = _capacity = 0;//置0}return _str;//返回字符串的首地址，用于打印数据}return _size;}assert(pos  
          8，尾插一个字符
           
          8.1 先判断容量是否足够，再插入。
          8.2 注意\0的处理。
           
          //尾插一个字符void string::push_back(char ch){if (_size == _capacity){//先计算容量，2倍增size_t newcapacity = _capacity == 0 ? 4 : _capacity * 2;//再扩容reserve(newcapacity);}_str[_size] = ch;//覆盖
          9，尾插一个字符串
          的位置_str[_size + 1] = '
          //尾插字符串void string::append(const char* str){size_t len = strlen(str);if (_size + len > _capacity){reserve(_size + len);}//strcat:从
          10，+=运算符重载
          的位置开始追加，最后自动补上
          string& string::operator+=(char ch){push_back(ch);return *this;}string& string::operator+=(const char* str){append(str);return *this;}
          //strcat(_str, str);strcpy(_str + _size, str);_size += len;}
          ';//补上
          11，在pos位置插入字符/字符串
          ++_size;}
           
          11.1 在pos位置插入字符
           
          9.1 先判断容量是否足够，再插入。
          9.2 插入字符串时strcat 和strcpy均可以实现。但是strcat的底层需要遍历找到\0再进行拼接，最后自动补上\0，效率不高；所以推荐使用strcpy。
           
          void string::insert(size_t pos, char ch){assert(pos size_t newcapacity = _capacity == 0 ? 4 : _capacity * 2;reserve(newcapacity);}size_t end = _size;while (end = pos){_str[end + 1] = _str[end];--end;}_str[pos] = ch;++_size;}
           
          //在指定位置插入 void string::insert(size_t pos, char ch){assert(pos size_t newcapacity = _capacity == 0 ? 4 : _capacity * 2;reserve(newcapacity);}int end = _size;while (end = (int)pos){_str[end + 1] = _str[end];--end;}_str[pos] = ch;++_size;}
           
          它的功能也是用来尾插字符或是字符串的，而且它比push_back和append使用的更广泛。
           
          //在指定位置插入 void string::insert(size_t pos, char ch){assert(pos size_t newcapacity = _capacity == 0 ? 4 : _capacity * 2;reserve(newcapacity);}size_t end = _size + 1;while (end  pos){_str[end] = _str[end - 1];--end;}_str[pos] = ch;++_size;}
           
          11.2 尾插一个字符串
           
          void string::insert(size_t pos, const char* str){assert(pos  _capacity){reserve(_size + len);}//方式1/*int end = _size;while (end >= (int)pos){_str[end + len] = _str[end];end--;}*///方式2size_t end = _size + len;while (end > pos+len-1){_str[end] = _str[end - 1];end--;}memcpy(_str + pos, str, len);_size += len;}
           
          错误示范：
          原因：当pos为0，即头插时，程序崩溃！因为end是无符号整形，减到0再减后会变成整形最大值(40多亿)，造成***循环。
           
          猜想解决方法：
          只把end的类型改为int，也不行。因为当一个操作符两边的操作数类型不一样时，会产生隐式类型转换，比如有符号与无符号，有符号会隐式转换成无符号类型。
           
          12，从pos位置开始删除长度为len的字符串
           
          解决方法1：
          把end的类型改为int，end指向最后一位有效位的下一位，把pos也强转为int类型。
           
          void string::erase(size_t pos, size_t len ){assert(pos  = _size){_str[pos] = '
          13，从pos位置开始查找字符/字符串
          ';_size = pos;}else{strcpy(_str + pos, _str + pos + len);_size -= len;}}
           
          解决方法2：
          让end指向\0的下一位。
           
          13.1 查找字符
           
          13.2 查找字符串
           
          遇到的问题与上面的相同。
           
          size_t string::find(const char* str, size_t pos){//strstr：str存在时返回所在位置的指针const char* p = strstr(_str + pos, str);return p - _str;}
           
          14，拷贝构造(传统)
           
          注意：
          1.此处在声明中两个形参的缺省值，size_t pos = 0， size_t len = npos。
          npos是const类型的静态成员变量，npos = -1，表示无符号整形的最大值(40多亿)。
           
          2.声明和定义分离时，静态成员变量的初始化。当是const修饰的size_t类型的静态变量时，是可以在声明时给缺省值的！这是个特例！ 但是一般不这样，声明和定义分离时，只要在.cpp中初始化即可。
           
          //要用深拷贝进行拷贝构造//s2(s1);把s1拷贝给s2,*this是s2,s是s1的别名string::string(const string& s){//开一个和要拷贝的一样大小的空间_str = new char[s._capacity + 1];strcpy(_str, s._str);//把数据拷贝进新空间_size = s._size;_capacity = s._capacity;}
           
          15，=赋值拷贝(传统)
           
          //s1 = s3;//s1是*this,s是s3的别名string& string::operator=(const string& s){//避免自己给自己赋值if (this != &s){     //多开一个空间给
          16，交换函数swap
          char* tmp = new char[s._capacity + 1];strcpy(tmp, s._str);delete[] _str;_str = tmp;_size = s._size;_capacity = s._capacity;return *this;}}
           
          size_t string::find(char ch, size_t pos){for (size_t i = pos; i  
          //s1.swap(s3)void string::swap(string& s){//调用库中的swap函数，交换内置类型//不直接交换数据，而是交换两块空间的指针std::swap(_str, s._str);std::swap(_size, s._size);std::swap(_capacity, s._capacity);}
           
          17，从pos位置开始取len个字符的串
           
          18. 字符串的比较
           
          当我们不显示实现深拷贝时，使用编译器默认的浅拷贝有两个危害：
          14.1 s1和s2指向同一块空间，出了作用域时调用两次析构函数，造成程序崩溃。
          14.2 修改一个，另外一个也会修改。
             
          开新空间，拷贝数据，释放原空间，改变指针指向。
               
          复用了前面的构造函数和+=运算符。
           
          string string::substr(size_t pos, size_t len){//len大于pos后面剩余的字符，有多少取多少if (len > _size - pos){string sub(_str + pos);//直接构造子串返回return sub;}else{string sub;sub.reserve(len);for (size_t i = 0; i   
          只要实现>运算符(或return strcmp(_str, s._str)