【C++ • STL】探究string的源码

文章目录

• 一、深浅拷贝
• 二、传统版写法的string类（简单）
• 三、string类的模拟实现
• 四、现代版写法的string类
• 五、���结

  ---

  ヾ(๑╹◡╹)ﾉ" 人总要为过去的懒惰而付出代价ヾ(๑╹◡╹)ﾉ"

  ---

  一、深浅拷贝

  浅拷贝：也称位拷贝，编译器只是将对象中的值拷贝过来。如果对象中管理资源，最后就会导致多个对象共享同一份资源，当一个对象销毁时就会将该资源释放掉，而此时另一些对象不知道该资源已经被释放，以为还有效，所以当继续对资源进项操作时，就会发生发生了访问违规。

  浅拷贝：（1）析构两次，造成程序崩溃（2）一个对象修改影响另外一个

  如果一个类中涉及到资源的管理，其拷贝构造函数、赋值运算符重载以及析构函数必须要显式给出。一般情况都是按照深拷贝方式提供。

  编译器默认生成的拷贝构造，是浅拷贝，会是两个对象指向同一块空间，当程序结束的时候，那么两个对象都会进行销毁，那么一块空间就会进行多次释放，从而引起崩溃。

  深拷贝：给每一个对象分配资源，保证多个对象之间不会因为共享资源而导致多次释放造成程序崩溃。

  二、传统版写法的string类（简单）

  #pragma once#include using namespace std;#include namespace yyqx//为了与库里面的string进行区分{//仅仅实现一个简单的string，仅仅考虑资源管理深浅拷贝问题class string{public://构造函数string(const char* str):_str(new char[strlen(str) + 1])//这里的+1，是为了'\0'开辟空间{strcpy(_str, str);//拷贝的时候'\0'也拷贝了}//拷贝构造（深拷贝）//s2(s1)string(const string& s):_str(new char[strlen(s._str) + 1]){strcpy(_str, s._str);}//赋值，也会有深浅拷贝的问题string& operator=(const string& s){if (this != &s)//避免自己给自己赋值，会导致值被释放，就会变成随机值{//delete[] _str;//首先进行释放//_str = new char[strlen(s._str) + 1];//C++的new是不需要检查是否开辟空间会抛异常//strcpy(_str, s._str);//为了避免开辟空间失败，而本来的空间也被我们释放，可以先开启空间，//进行拷贝，然后再释放char* tmp = new char[strlen(s._str) + 1];strcpy(tmp, s._str);delete[] _str;_str = tmp;}return *this;}//析构函数~string(){if (_str){delete[] _str;}}//目的为了输出字符串const char* c_str() const{return _str;}//返回c格式的字符串//重载[]char& operator[](size_t pos){assert(pos  
  赋值运算符重载也会有深浅拷贝的问题。赋值，对象本身是有值的【拷贝的时候，如果空间小，就会不够，空间大，就会造成资源浪费】
   
  三、string类的模拟实现
   
  string的增删查改以及使用string【传统】
  基本框架：
   
  #pragma once#include using namespace std;#include namespace yyqx//为了与库里面的string进行区分{class string{public:
   
  构造函数+析构函数：
  写法1：
   
  //构造函数string(const char* str):_size(strlen(str)),_capacity(_size){_str = new char[strlen(str) + 1];//这里的+1，是为了'
  构造函数：初始化列表，初始化的顺序并不是初始化列表的顺序，而是成员变量在类中的声明次序。
  '开辟空间strcpy(_str, str);//拷贝的时候'
  string(const char* str = "")//这里默认值不能给nullptr，strlen以及拷贝strcpy会崩溃:_size(strlen(str)),_capacity(_size){_str = new char[strlen(str) + 1];//这里的+1，是为了'
  缺省值这不能给nullptr，strlen以及拷贝strcpy时程序会崩溃
  '开辟空间strcpy(_str, str);//拷贝的时候'
  注意初始化列表
  '也拷贝了}//析构函数~string(){if (_str){delete[] _str;_str = nullptr;//好习惯_size = 0;_capacity = 0;}}
  '也拷贝了}string()//注意，这里不是给的空，而是给了一个空的字符串//标准库里的就是给了一个"":_size(0),_capacity(0){_str = new char[1];_str[0] = '
  strcpy注意，拷贝的时候’
  string& operator+=(char ch){push_back(ch);return *this;}string& operator+=(const char* str){append(str);return *this;}void reverse(size_t n)//一个扩容的作用{if (n > _capacity){char* tmp = new char[n + 1];strcpy(tmp, _str);delete[] _str;//注意这里的释放不是free_str = tmp;_capacity = n;}}void resize(size_t n, char ch = '
  判断容量是否满，如果 _size= _ capacity,容量扩2倍，new一个新容量的空间,释放旧空间，最后指针指向新的空间。
  '){if (n  _capacity){reverse(n);}for (size_t i = _size; i  _capacity){reverse(len);}strcpy(_str + _size, str);_size = len;}//但是我们一般用+=
  ’也拷贝了
  ';}
   

  • append （append插入的字符个数是未知的，扩容二倍也不一定足够：解决办法：reverse预留空间【一个扩容的作用】）
  • 构造函数：注意默认的构造函数【编译器自动生成、缺省、函数重载】，默认的构造函数这里选择写一个同名函数，注意这里并不是给一个空指针，而是给了一个空字符串。

    写法2：（最优写法）

  • reverse 为string预留空间，避免多次扩容（提高效率）

  string& insert(size_t pos, char ch){assert(pos reverse(_capacity == 0 ? 4 : 2 * _capacity);}//不可以用strcpy,这里不可以是同一块地址，对导致内容不是我们想要的//最后一个未知的字符移到_size然后就是倒数第二位移动，从后向前移动size_t end = _size + 1;//注意这里如果end=_size，当头插的时候，进入循环end会变成-1，因为是size_t所以又会进入循环，导致错误while (end  pos){_str[end] = _str[end - 1];--end;}_str[pos] = ch;_size++;return *this;}//插入
  不可以用strcpy,在字符进行向后移的时候，不可以是同一块地址，对导致内容不是我们想要的，最后一个未知的字符移到_size然后就是倒数第二位移动，从后向前移动
  ，用c_str(遇到
  //删除string& erase(size_t pos, size_t len = npos){assert(pos = npos){_str[pos] = '';_size = pos;}else{size_t begin = pos + len;while (begin _str[begin - len] = _str[begin];++begin;}_size -= len;}return *this;}for (; pos 
  停止打印)打印显示在屏幕的字符串长度会减小或者不变，但是_size会变大//用范围for或者迭代器可以打印出来string& insert(size_t pos, const char* str){assert(pos  _capacity){reverse(_size + len);}size_t end = _size + len;while (end > pos + len - 1)//这里注意{_str[end] = _str[end - len];--end;}strncpy(_str + pos, str, len);//防止为了遇见就不拷贝了(strcpy遇见就不拷贝了)_size += len;return *this;}

  • new开空间的时候，一定要多开一个给’\0’

    拷贝构造+赋值重载函数+其他：

    //拷贝构造（深拷贝）//s2(s1)string(const string& s):_size(strlen(s._str)),_capacity(_size){_str = new char[_capacity + 1];strcpy(_str, s._str);}//赋值，也会有深浅拷贝的问题string& operator=(const string& s){if (this != &s)//避免自己给自己赋值，会导致值被释放，就会变成随机值{char* tmp = new char[s._capacity + 1];strcpy(tmp, s._str);delete[] _str;_str = tmp;_size = s._size;_capacity = s._capacity;}return *this;}//目的为了输出字符串const char* c_str() const{return _str;}//返回c格式的字符串char& operator[](size_t pos)//这里仅仅可以传入对象，不能传入const对象，如果是const对象，就会报错{assert(pos  
    添加：
      

    • resize用处：扩空间+初始化；删除数据保留前n个

      插入：

      插入字符：

      • end=_size，当头插的时候，进入循环end会变成-1，因为是size_t，又是大于0所以又会进入循环，导致代码错误

        插入字符串：

        • 防止为了遇见\0就不拷贝了，所以用的是strncpy(strcpy遇见\0就不拷贝了)

          删除：