• string类的模拟实现（万字讲解超详细）

    目录

    前言

    1.命名空间的使用

    2.string的成员变量

    3.构造函数

    4.析构函数

    5.拷贝构造

     5.1 swap交换函数的实现

    6.赋值运算符重载

    7.迭代器部分

    8.数据容量控制

    8.1 size和capacity

    8.2 empty

    9.数据修改部分

    9.1 push_back

    9.2  append添加字符串

    9.3 +=运算符重载

    9.4 clear函数

    9.5 insert

    9.6 erase

    9.7 substr

    9.8 []运算符的重载

    10.c_str

    11.关系运算符

    12. find函数

    13.<<流插入操作符重载

    14.>>流提取

    总代码：

    前言

    这里我们就开始介绍我们string的模拟实现了，我相信在经过之前给大家介绍的标准库string类的使用后，大家对我们的string类都已经有一定的认识，心里对该底层实现也有了一定的猜想，那么现在我们就为大家打消疑虑，给大家揭开我们string神秘的面纱（注意：小编这里只给大家是实现了一部分我们经常使用的函数）。

    1.命名空间的使用

    首先我们需要使用我们命名空间来避免和我们的库中的string导致冲突

    1. namespace xhj
    2.  
    3. {
    4.  
    5.     class string
    6.  
    7.     {
    8.  
    9.     
    10.     };
    11.    
    12. };

    2.string的成员变量

    要知道我们string的成员变量，我们要从两个方面入手，首先是我们的string的存储结构，其次是根据我们string的成员函数。

    1.很明显我们的string存储的是一串字符串，那么该底层的存储结构用的就是我们的char类型的变长数组数组，因此我们确定了第一个变量就是我们的char类型的指针

    2.第二根据我们的size（），返回我们的有效字符个数，因此我们要使用一个int类型的变量记录我们的有效字符个数。

    3.第三就是我们的capacity（）了，这里我们就需要使用一个int类型变量，记录我们的容量大小

    4.第四点比较难想到，但是小编在之前给大家提到了一个静态变量npos，这个在string常用来表示我们无限大，因此该是确定的一个size_t类型的常变量。

    因此我们的成员变量如下：

    1.  
    2. namespace xhj
    3.  
    4. {
    5.  
    6.     class string
    7.  
    8.     {
    9.  
    10.      private:
    11.  
    12.         char* _str;
    13.  
    14.         size_t _capacity;
    15.  
    16.         size_t _size;
    17.         const static size_t npos;
    18.     };
    19.    const  size_t string::npos = -1;
    20. };

    3.构造函数

    这里我们只需要实现我们比较重要的两个即可，也就是我们的无参构造，和我们的C-string进行的构造，但是这里我们可以使用我们的缺省参数将两个合并为一个，代码如下：

    1.  string(const char* str = "")
    2.         {
    3.             _size = strlen(str);
    4.             _capacity = _size;
    5.             _str = new char[_capacity + 1];//由于多一位需要存储我们的‘/0’,因此要进行+1
    6.             strcpy(_str, str);
    7.         }

    4.析构函数

     对于析构函数我们是需要自己实现的，因为这里都是内置类型，且我们这些内置类型中我们还开辟了新的空间如果我们不自己实现，很大程度会造成内存的泄露。

    1. ~string()
    2. {
    3.    delete[] _str;
    4.   _str = nullptr;
    5.   _size = _capacity = 0;
    6.  }

    5.拷贝构造

    在实现拷贝构造前我们需要确认我们是否需要写我们的拷贝构造，很明显我们这里是非常有必要的，因为这里会涉及到浅拷贝的问题：

    因此以下我们需要实现我们的深拷贝。

     5.1 swap交换函数的实现

    为什么我们在介绍拷贝构造函数之前，要先给大家介绍我们的交换函数呢?这里就涉及了我们拷贝构造函数的两种写法。

    实现我们的swap函数是非常简单的，也就是：

    1. void swap(string& s)
    2.         {
    3.           //这里调用的是我们算法库中的函数
    4.             std::swap(_str, s._str);
    5.             std::swap(_size, s._size);
    6.             std::swap(_capacity, s._capacity);
    7.  
    8.         }

    那么我们的拷贝构造的两类写法是：

    传统写法：

    1.  string(const string& s)
    2.             :_str(nullptr)
    3.             ,_size(0)
    4.             , _capacity(0)
    5.         {
    6.             //传统写法
    7.             _size = s._size;
    8.             _capacity = s._capacity;
    9.             _str = new char[_capacity + 1];
    10.             memcpy(_str, s._str,s._size+1);
    11.             //C语言的字符数组，是以\0为终止算长度
    12.             //string不看\0，而是以size算终止长度
    13.         }

    现代写法：

      注意：对于传统写法，我们的现代写法依赖于编译器对数据的初始化，如果编译没有对数据进行初始化操作那么在交换的过程中很可能会出现随机值的情况，然后在最后对tmp进行析构的时候就会出现程序崩溃的情况，所以这里我们需要先走初始化列表

    1. string(const string& s)
    2.             :_str(nullptr)
    3.             ,_size(0)
    4.             , _capacity(0)
    5.         {
    6.             //现代写法
    7.             string tmp(s._str);
    8.             swap(tmp);
    9.  
    10.         }

    对于传统写法我相信大家都能理解，对于现代写法这里小编就需要给大家解释一下了，我们这里先调用构造函数，使用我们s这个对象的_str部分去构造我们的tmp对象，这里我们只需要将我们的tmp和我们的当前对象进行交换，这也就达成了我们的当前对象的所有成员对象都赋予了我们tmp的值，而我们的当前地址空间，只需要交给我们的tmp出局部作用域进行销毁，也就是：

    6.赋值运算符重载

    对于赋值运算符我们也是需要进行重载的，这里也牵涉到我们的浅拷贝带来的问题，因此我们这里也是需要重新开辟一段空间进行我们数据的存储的，那么这里我们也有我们的两种写法：

    注意：1.我们的原本空间可能小于我们的形参的数据空间，因此我们要重新开辟新空间 

               2.不要使用原空间指针开辟新空间，以免开空间失败破坏原空间

    传统版本：

    1.         string& operator=(const string& s)
    2.         {
    3.             if (this != &s)
    4.             {
    5.                 //传统写法
    6.                char* temp = new char[s._capacity + 1];//避免我们原本指针开空间失败导致旧空间被破坏
    7.                 memcpy(temp, s._str, s._size + 1);
    8.                 delete[]_str;
    9.                 _str = temp;
    10.                 _size = s._size;
    11.                 _capacity = s._capacity;
    12.             }
    13.             return *this;
    14.         }

    现代版本：

    1.         string& operator=(string s)//传值传参调用拷贝构造
    2.         {
    3.             swap(s);
    4.             return *this;
    5.         }

    对于传统版本相信凭借大家的基础一定是随便掌握，这里小编仅给大家介绍一下我们的现代版本，这里我们先让此处直接进行传值传参，调用我们的拷贝构造，那么我们此时的s对象就是我们外部参数的一个拷贝，那么我们直接使用老方法，将我们s产生的新空间给我们的当前对象，我们的旧空间就给我们的s出作用域的时候销毁即可。

    7.迭代器部分

    对于迭代器部分，首先我们要想到该使用方式：

    1.     string s1("hello world");
    2. 	string::iterator it = s1.begin();
    3. 	while (it != s1.end())
    4. 	{
    5. 		cout << *it << " ";
    6. 		it++;
    7. 	}

    通过该定义的方式我们可以看出，我们的迭代器也是一个类型，一个被定义在string类中的类型，而对于该使用方式来看我们的迭代器很类似于我们的指针，而实际上我们的迭代器就是我们的指针，或者是对我们指针进行封装的类，那么该打印结果是：

    那么很明显，我们的是从头到尾的一个遍历的过程，而我们的begin（）函数返回的就是我们的数组首元素的地址，我们的end()函数返回的就是我们数组末尾的下一个位置的地址。此外我们的迭代器（这里仅仅给大家介绍我们的正向迭代器，对于反向迭代器，小编会在之后的内容给大家介绍)在库中一共分为两个版本：

    一个是我们的普通版本，一个是我们的const版本，那么这两者又有着什么不同呢？首先对于我们普通迭代器，我们即允许了读，也允许了写，而我们的const版本只允许读而不允许写，其次就是我们调用对象的不同，我们的iterator是给普通对象调用的，我们的const_iterator就需要我们用我们的const修饰我们的this指针，虽然按照语法来说该既可以被我们的普通对象调用（权限缩小）,也可以被我们的const对象调用（权限平移），但是在iterator版本出现时我们的编译器在每次调用中会给我们最匹配的那个，因此也就达到了我们的普通对象调用我们的普通版本，const对象调用我们const版本。

    那么该具体实现如下：

    1.        typedef char* iterator;
    2.        typedef const char* const_iterator;
    3.         iterator begin()
    4.         {
    5.             return _str;
    6.         }
    7.         const_iterator begin() const
    8.         {
    9.             return _str;
    10.         }
    11.  
    12.         iterator end()
    13.         {
    14.             return _str + _size;
    15.         }
    16.         const_iterator end() const
    17.         {
    18.             return _str + _size;
    19.         }

    那么之前给大家介绍了范围for，实际上我们的范围for就是我们以上正向迭代器的使用放式，只不过上层做了一层封装，因此只有有迭代器才可以使用我们的范围for

    8.数据容量控制

    数据的容量控制，我们就需要实现以下几个函数：

    8.1 size和capacity

    首先是我们获取我们有效数据和容量大小的函数

    1.  
    2.         size_t size()const
    3.         {
    4.             return _size;
    5.         }
    6.         size_t capacity()const
    7.         {
    8.             return _capacity;
    9.          }

    8.2 empty

    其次是我们判断我们的有效数据是否为空

    1.         bool empty()const//这里不仅仅要被我们的普通对象调用，也要被我们的const对象调用
    2.         {
    3.             return _size == 0;
    4.         }

    最后比较关键的两个就是我们有效数据控制和我们容量控制的函数：

    容量控制函数：

    1.         void reserve(size_t n)
    2.         {
    3.             if (n > _capacity)//只有空间大小大于当前才需要进行扩容
    4.             {
    5.                 char* temp;
    6.                 temp = new char[n + 1];//多的一个用于存储'/0'
    7.                 memcpy(temp, _str,_size+1);
    8.                 delete[]_str;
    9.                 _str = temp;
    10.                 _capacity = n;
    11.             }
    12.         }

    对于扩容逻辑我想大家并不陌生，这里就是我们开辟一个新的扩容后的空间，再将我们当前的内容拷贝到我们扩容后的空间，最后将我们的当前指针指向新开辟好的空间即可。

    有效数据个数控制函数：

    1.         void resize(size_t n, char c = '\0')
    2.         {
    3.             if (n < _size)
    4.             {
    5.                 _str[n] = '\0';
    6.                 _size = n;
    7.             }
    8.             else
    9.             {
    10.                 reserve(n);
    11.                 for (int i = _size; i < n; i++)
    12.                 {
    13.                     _str[i] = c;
    14.                 }
    15.                 _size = n;
    16.                 _str[_size] = '\0';
    17.                 
    18.             }
    19.         }

    以上我们一共存在三种情况：

    n<_size 直接删除数据：只需要我们将有效位置的位置的下一个置为‘/0’,然后改变我们的——_size即可

    _size这里只需要从原先的_size开始依次往后填写直到达到我们有效数据个数即可，最后需要改变我们的_size大小，然后最后一位存上我们的'/0'。

    n>capacity 扩容+初始化：我们这里的操作只是比我们的情况二多了一个扩容操作，这里小编将情况三和情况二的判断放在了我们的reserve函数中，大家可以体会一下。

    9.数据修改部分

    9.1 push_back

    我们的push_back通常只是在后面添加字符，但是在添加字符的过程中我们需要注意到的就是我们在添加过后是否需要进行增容，代码如下：

    1.         void push_back(char c)
    2.         {
    3.             if (_capacity = _size)
    4.             {
    5.                 reserve(_capacity == 0 ? 4 : _capacity * 2);
    6.             }
    7.             _str[_size] = c;
    8.             _size++;
    9.             _str[_size] = '\0';
    10.          }

    这里我们扩容逻辑是，当我们的_capacity和我们的_size相等时就需要进行扩容，也就是说当我们的有效数据和我们的容量大小相等时就需要进行扩容，这里我们的扩容逻辑就是，当我们的容量为0的时候就只开四个空间，其余情况按照旧容量的两倍进行扩容，最后就是将我们的添加的字符放在我们的数组末，然后将我们的_size++，最后记得将有效数据的下一位赋值上我们的'/0'即可。

    9.2  append添加字符串

    这里小编仅仅给大家实现了我们append添加字符串的那个版本，在实现的过程中我们任然需要注意的是我们的扩容操作，代码如下：

    1.        void append(const char* str)
    2.         {
    3.             size_t len = strlen(str);
    4.             if (_size + len > _capacity)//判断是否需要进行扩容
    5.             {
    6.                 reserve(_size + len);//扩容到能够存储我们新增字符串大小
    7.             }
    8.             strcpy(_str + _size, str);//从_size位置开始将我们新增字符串复制到该后面
    9.             _size = _size + len;//更新我们的_size
    10.  
    11.         }

    9.3 +=运算符重载

    我们的+=运算符，是我们string类，常用于添加我们的字符串或者字符的一个操作符，那么该如何同时能添加字符串和我们的操作符的呢？很简单，那就是我们的函数重载。

    字符版本：

    1.         string& operator+=(char c)//这里我们的*this并没有被销毁，所以可以使用引用返回
    2.         {
    3.             push_back(c);
    4.             return *this;//注意我们的+=需要返回+=后的值
    5.         }

    这里我们发现实际上这里只是对我们push_back的一个复用，那么字符串版本呢？相信聪明的小伙伴已经猜到了，没错，这里就是对我们append的一个复用。

    字符串版本：

    1.         string& operator+=(const char* str)
    2.         {
    3.             append(str);
    4.             return* this;
    5.         }

    9.4 clear函数

    clear函数的作用就是清除我们string对象中所有有效元素，这实际上是非常简单的一种操作，只需要更改我们的_size为,以及将我们数组的起始位置填上'/0'即可。

    1.         void clear()
    2.         {
    3.             _str[0] = '\0';
    4.             _size = 0;
    5.         }

    9.5 insert

    我们的insert，小编这里也给大家实现两个版本,一个是在pos位置前插入我们n个字符c，一个是在我们pos位置前插入字符串。

    版本一：

    1.        void insert(size_t pos,size_t n, char c)
    2.         {
    3.             assert(pos < _size);//判断pos位置的合理性
    4.             if (_size + n > _capacity)//判断是否需要进行扩容操作
    5.             {
    6.                 reserve(_size + n);
    7.             }
    8.             size_t end = _size;//end指向我们的数组末尾
    9.             while (end >= pos && end != npos)//当我们的end大于我们的pos，且我们end值合理时
    10.             {
    11.                 _str[end + n] = _str[end];//往后移动数据
    12.                 --end;//pos位置以及该后的得全部要往后移n位
    13.             }
    14.  
    15.             for (size_t i = 0; i < n; i++)//从pos位置写入我们n个c
    16.             {
    17.                 _str[pos + i] = c;
    18.             }
    19.  
    20.             _size += n;//修改我们的_size的值
    21.         }

    版本二：

    1.         void insert(size_t pos, const char* str)
    2.         {
    3.             assert(pos < _size);//判断pos位置的合法性
    4.             size_t len = strlen(str);//获取字符串长度，方便后续操作
    5.             if (_size + len> _capacity)//判断是否需要扩容
    6.             {
    7.                 reserve(_size + len);
    8.             }
    9.             size_t end = _size;
    10.             while (end >= pos && end != npos)//移动元素
    11.             {
    12.                 _str[end + len] = _str[end];
    13.                 --end;
    14.             }
    15.  
    16.             for (size_t i = 0; i < len; i++)//写入元素
    17.             {
    18.                 _str[pos + i] = str[i];
    19.             }
    20.  
    21.             _size += len;
    22.         }

    这里我们的版本二实际上和我们版本一的思路是一样的，只不过该插入字符串时需要判断字符串长度，才能进行元素的移动和元素的写入。

    9.6 erase

    删除pos位置开始的len长度的字符

    这里我们的删除我们是需要分情况讨论的

    1. 当我们的pos+len>=size或者我们的len=npos,那么说明我们pos位置开始的值是要全部删除的，也就是。

           2.诺pos+len

    代码如下：

    1.         void erase(size_t pos, size_t len=npos)
    2.         {
    3.             assert(pos < _size);//判断pos位置的合法性
    4.             if (len == npos || pos + len > _size)
    5.             {
    6.                //全部删除
    7.                 _str[pos] = '\0';
    8.                 _size = pos;
    9.             }
    10.             else
    11.             {
    12.                //部分删除
    13.                 size_t end = pos + len;
    14.                 while (end <= _size)//注意我们是<=,因为此处需要将/0也移过来
    15.                 {
    16.                     _str[pos++] = _str[end++];
    17.                 }
    18.                 _size = _size - len;
    19.             }
    20.         }

    9.7 substr

    该函数的作用是截取从pos位置开始的len长度的字符串，注意该函数的返回值是一个我们的string对象，该函数也有两类情况：

    情况一：len==npos或者len+pos>size,这里就需要将我们pos后面的值全部截取，但是对于截取我们部分截取和全部截取的逻辑都是一致的，这里我们需要注意的是我们需要修正我们的len值，否则就会造成我们的越界截取。

    情况二：pos+len 

    1.         string substr(size_t pos = 0, size_t len = npos)
    2.         {
    3.             assert(pos < _size);
    4.  
    5.             size_t n = len;
    6.             if (len == npos || pos + len > _size)
    7.             {
    8.                //修正len
    9.                 n = _size - pos;
    10.             }
    11.             //截取逻辑
    12.             string tmp;
    13.             tmp.reserve(n);
    14.             for (size_t i = pos; i < pos + n; i++)
    15.             {
    16.                 tmp += _str[i];//复用
    17.             }
    18.  
    19.             return tmp;
    20.         }

    9.8 []运算符的重载

    为什么要重载我们的[]呢？因为我们的string类是将我们的底层数组封装了，外界并不能直接访问，因此我们要提供我们的[]接口，给大家使用从而间接访问到我们的底层数组，但是需要注意的是我们[]涉及到数据的写入和读取，因此该要提供给我们的普通对象读取和写入的权力，给我们的const对象只提供读取的权力，因此这里也就要实现两个版本：

    1.        char& operator[](size_t index)
    2.         {
    3.             assert(index < _size&&index>=0);
    4.             return _str[index];
    5.         }
    6.  
    7.         const char& operator[](size_t index)const
    8.         {
    9.             assert(index < _size&& index >= 0);
    10.             return _str[index];
    11.         }

    10.c_str

    之前给大家说过，我们这个接口是为了和我们C语言进行配合，因此我们返回的就是我们C语言字符串类型，也就是我们的字符指针

    1.         const char* c_str()const
    2.         {
    3.             return _str;
    4.         }

    11.关系运算符

    1.         bool operator<(const string& s) const
    2.         {
    3.             int ret = memcmp(_str, s._str, _size > s._size ? s._size : _size);
    4.             return ret == 0 ? _size < s._size : ret < 0;
    5.         }
    6.  
    7.         bool operator<=(const string& s) const
    8.         {
    9.             return(*this < s || *this == s);
    10.         }
    11.  
    12.         bool operator>(const string& s) const
    13.         {
    14.             return !(*this <= s);
    15.         }
    16.  
    17.         bool operator>=(const string& s) const
    18.         {
    19.             return !(*this < s);
    20.         }
    21.  
    22.         bool operator==(const string& s) const
    23.         {
    24.             return _size == s._size && memcmp(_str, s._str, _size)==0;
    25.         }
    26.  
    27.         bool operator!=(const string& s)const
    28.         {
    29.             return !(*this == s);
    30.         }

    对于我们的关系运算符，我们这里使用的是C语言的memcmp函数去比较我们的大小，由于我们的memcmp是按一个字节，一个字节去进行比较的，因此我们是按string中有效数据个数最短的那个对象去进行我们的比较操作，但是最短的字符比较肯会出现以下两类情况：

    这里我就给大家简单的介绍一下我们的<运算符以及==运算符的重载逻辑，其他的都是对两者的复用

    <预算符重载：

    ==运算符重载：

    12. find函数

    对于find函数我们这里给大家实现了两个版本，一个是查找单个字符，一个是查找字符串，对于查找字符串，我们可以使用我们C语言中学习过的strstr函数进行字串的查找

    单个字符版本：

    1.        size_t find(char c, size_t pos = 0) const
    2.         {
    3.             assert(pos < _size);
    4.             for (size_t i = pos; i < _size; i++)
    5.             {
    6.                 if (_str[i] == c)
    7.                 {
    8.                     return i;
    9.                 }
    10.             }
    11.  
    12.             return npos;
    13.         }

    字符串版本：

    1.         size_t find(const char* s, size_t pos = 0) const
    2.         {
    3.             assert(pos < _size);
    4.  
    5.             const char* ptr = strstr(_str + pos, s);
    6.             if (ptr)
    7.             {
    8.                 return ptr - _str;
    9.             }
    10.             else
    11.             {
    12.                 return npos;
    13.             }
    14.         }

    对于这里的实现都比较简单，大家只需要注意找不到返回我们的npos即可。

    13.<<流插入操作符重载

    在给大家介绍友元函数的时候，就给大家介绍过一次我们Date类的流插入运算符的重载，由于我们的流插入的调用参数的原因，我们不得不把我们的该函数写在类外，然后又由于我们要直接去访问我们的私有成员变量，又不得不去构造我们的友元关系。那么实际上我们也可以通过间接的函数去获得我们的内部成员，但是我们C++语言是不常使用的，但是对于我们string的<<操作符我们是否可以调用我们的C-str接口去实现我们这个接口呢？

    答案是不行的，原因是我们的C-str返会的是我们C语言的字符串，因此遇到\0，会自动停止打印，但是我们的string类是以我们的size作为结束标志，因此这里是不可取的。

    因此我们这里是通过构造友元关系实现的，具体实现代码如下：

    1.   ostream& operator<<(ostream& out, const string& s)
    2.    {
    3.        for (auto ch : s)
    4.        {
    5.            out << ch;
    6.        }
    7.        return out;
    8.    }

    14.>>流提取

    在实现流提取我们需要注意一点就是，我们这里的流提取在遇到空格和我们的\n就会停止读取，因此我们要在此处加以我们的判断。

    1.  istream& operator>>(istream& _cin, xhj::string& s)
    2.    {
    3.       char ch;
    4.       _cin >> ch;
    5.        while (ch != ' ' && ch != '\n')
    6.        {
    7.            
    8.            s += buff;
    9.            _cin >> ch;
    10.        }
    11.        return _cin;
    12.    }

    这里我给大家提供了一个版本，不过这个版本是一个错误版本，且就算成功该也会带来极大的资源损耗原因在于

    1. _cin在输入数据到缓冲区的时候，我们的空格和\n，并不能被存储在我们的缓冲区，因为这里被认为是我们多个值的间隔，会造成死循环
    2. 这里就算不会造成死循环，每次读取一个值就写入我们的对象中，就会导致我们空间的扩容过于频繁，导致资源损耗。

    那么对于以上问题我们各自采用的解决方案是什么呢？

    1. 首先是解决我们空格和我们\n的读取问题，这里就需要我们使用我们的get函数，这个函数就会对其进行读取
    2. 然后扩容过于频繁，我们这里的解决方案就是使用一个数组进行写入，当这个数组被写满之后，直接一次性写入到我们的对象中，接下来请看代码
    1. istream& operator>>(istream& _cin, xhj::string& s)
    2.    {
    3.        char ch = _cin.get();
    4.        s.clear();//为了每次达到输入后覆盖的效果
    5.        char buff[128];//这里使用数组首先是避免了每次+=造成的多次开辟空间而导致效率上的降低
    6.                        //其次避免了我们预先在堆上开辟大量空间而可能造成空间浪费的情况
    7.        //清理缓冲区
    8.        while (ch == ' ' || ch == '\n')
    9.        {
    10.            ch = _cin.get();
    11.        }
    12.        int i = 0;
    13.        while (ch != ' ' && ch != '\n')
    14.        {
    15.            buff[i++] = ch;
    16.            if (i == 127)
    17.            { 
    18.                buff[i] = '\0';
    19.                s += buff;
    20.                i = 0;
    21.            }
    22.            ch = _cin.get();
    23.        }
    24.        if (i != 0)
    25.        {
    26.            buff[i] = '\0';
    27.            s += buff;
    28.        }
    29.        return _cin;
    30.    }

    此外我们的clear是对该对象中原先的值进行清理，以达到我们后输入的值对其进行覆盖的效果。

    总代码：

    1. #include
    2. #include
    3. using namespace std;
    4. namespace xhj
    5.  
    6. {
    7.  
    8.     class string
    9.  
    10.     {
    11.  
    12.         friend ostream& operator<<(ostream& _cout, const xhj::string& s);
    13.  
    14.         friend istream& operator>>(istream& _cin, xhj::string& s);
    15.  
    16.     public:
    17.  
    18.         typedef char* iterator;
    19.         typedef const char* const_iterator;
    20.  
    21.     public:
    22.  
    23.         string(const char* str = "")
    24.         {
    25.             _size = strlen(str);
    26.             _capacity = _size;
    27.             _str = new char[_capacity + 1];//由于多一位需要存储我们的‘/0’,因此要进行+1
    28.             strcpy(_str, str);
    29.         }
    30.         //对于传统写法，我们的现代写法依赖于编译器对数据的初始化，如果编译没有对数据进行初始化操作那么在交换的过程中很可能会出现随机值的情况
    31.         //然后在最后对tmp进行析构的时候就会出现程序崩溃的情况，所以这里我们需要先走初始化列表
    32.         string(const string& s)
    33.             :_str(nullptr)
    34.             ,_size(0)
    35.             , _capacity(0)
    36.         {
    37.             //传统写法
    38.             /*_size = s._size;
    39.             _capacity = s._capacity;
    40.             _str = new char[_capacity + 1];
    41.             memcpy(_str, s._str,s._size+1);*/
    42.             //C语言的字符数组，是以\0为终止算长度
    43.             //string不看\0，而是以size算终止长度
    44.             //现代写法
    45.             string tmp(s._str);
    46.             swap(tmp);
    47.         }
    48.  
    49.         /*string& operator=(const string& s)
    50.         {
    51.             if (this != &s)
    52.             {
    53.                 //传统写法
    54.                char* temp = new char[s._capacity + 1];
    55.                 memcpy(_str, s._str, s._size + 1);
    56.                 delete[]_str;
    57.                 _str = temp;
    58.                 _size = s._size;
    59.                 _capacity = s._capacity
    60.                 //现代写法：拷贝构造一个新的对象，让两者进行交换，可以将新的值搞到我们对应的对象，然后就空间可以让我们的局部对象出了作用域出了析构对象进行销毁
    61.                 string temp(s);
    62.                 std::swap(_str, temp._str);
    63.                 std::swap(_size, temp._size);
    64.                 std::swap(_capacity, temp._capacity);
    65.             }
    66.             return *this;
    67.         }*/
    68.         string& operator=(string s)//传值传参调用拷贝构造
    69.         {
    70.             swap(s);
    71.             return *this;
    72.         }
    73.  
    74.         ~string()
    75.         {
    76.             delete[] _str;
    77.             _str = nullptr;
    78.             _size = _capacity = 0;
    79.         }
    80.             // iterator
    81.  
    82.         iterator begin()
    83.         {
    84.             return _str;
    85.         }
    86.         const_iterator begin() const
    87.         {
    88.             return _str;
    89.         }
    90.  
    91.         iterator end()
    92.         {
    93.             return _str + _size;
    94.         }
    95.         const_iterator end() const
    96.         {
    97.             return _str + _size;
    98.         }
    99.             // modify
    100.  
    101.         void push_back(char c)
    102.         {
    103.             if (_capacity = _size)
    104.             {
    105.                 reserve(_capacity == 0 ? 4 : _capacity * 2);
    106.             }
    107.             _str[_size] = c;
    108.             _size++;
    109.             _str[_size] = '\0';
    110.          }
    111.  
    112.         string& operator+=(char c)
    113.         {
    114.             push_back(c);
    115.             return *this;
    116.  
    117.         }
    118.  
    119.         void append(const char* str)
    120.         {
    121.             size_t len = strlen(str);
    122.             if (_size + len > _capacity)
    123.             {
    124.                 reserve(_size + len);
    125.             }
    126.             strcpy(_str + _size, str);
    127.             _size = _size + len;
    128.  
    129.         }
    130.  
    131.         string& operator+=(const char* str)
    132.         {
    133.             append(str);
    134.             return* this;
    135.         }
    136.  
    137.         void clear()
    138.         {
    139.             _str[0] = '\0';
    140.             _size = 0;
    141.         }
    142.  
    143.         void swap(string& s)
    144.         {
    145.             std::swap(_str, s._str);
    146.             std::swap(_size, s._size);
    147.             std::swap(_capacity, s._capacity);
    148.  
    149.         }
    150.  
    151.         const char* c_str()const
    152.         {
    153.             return _str;
    154.         }
    155.  
    156.  
    157.  
    158.         /
    159.  
    160.         // capacity
    161.  
    162.         size_t size()const
    163.         {
    164.             return _size;
    165.         }
    166.  
    167.         size_t capacity()const
    168.         {
    169.             return _capacity;
    170.          }
    171.  
    172.         bool empty()const
    173.         {
    174.             return _size == 0;
    175.         }
    176.  
    177.         void resize(size_t n, char c = '\0')
    178.         {
    179.             if (n < _size)
    180.             {
    181.                 _str[n] = '\0';
    182.                 _size = n;
    183.             }
    184.             else
    185.             {
    186.                 reserve(n);
    187.                 for (int i = _size; i < n; i++)
    188.                 {
    189.                     _str[i] = c;
    190.                 }
    191.                 _size = n;
    192.                 _str[_size] = '\0';
    193.                 
    194.             }
    195.         }
    196.  
    197.         void reserve(size_t n)
    198.         {
    199.             if (n > _capacity)
    200.             {
    201.                 char* temp;
    202.                 temp = new char[n + 1];
    203.                 memcpy(temp, _str,_size+1);
    204.                 delete[]_str;
    205.                 _str = temp;
    206.                 _capacity = n;
    207.             }
    208.         }
    209.         
    210.         char& operator[](size_t index)
    211.         {
    212.             assert(index < _size&&index>=0);
    213.             return _str[index];
    214.         }
    215.  
    216.         const char& operator[](size_t index)const
    217.         {
    218.             assert(index < _size&& index >= 0);
    219.             return _str[index];
    220.         }
    221.  
    222.  
    223.  
    224.         /
    225.  
    226.         //relational operators
    227.  
    228.         bool operator<(const string& s) const
    229.         {
    230.             int ret = memcmp(_str, s._str, _size > s._size ? s._size : _size);
    231.             return ret == 0 ? _size < s._size : ret < 0;
    232.         }
    233.  
    234.         bool operator<=(const string& s) const
    235.         {
    236.             return(*this < s || *this == s);
    237.         }
    238.  
    239.         bool operator>(const string& s) const
    240.         {
    241.             return !(*this <= s);
    242.         }
    243.  
    244.         bool operator>=(const string& s) const
    245.         {
    246.             return !(*this < s);
    247.         }
    248.  
    249.         bool operator==(const string& s) const
    250.         {
    251.             return _size == s._size && memcmp(_str, s._str, _size)==0;
    252.         }
    253.  
    254.         bool operator!=(const string& s)const
    255.         {
    256.             return !(*this == s);
    257.         }
    258.  
    259.  
    260.  
    261.         // 返回c在string中第一次出现的位置
    262.  
    263.         size_t find(char c, size_t pos = 0) const
    264.         {
    265.             assert(pos < _size);
    266.             for (size_t i = pos; i < _size; i++)
    267.             {
    268.                 if (_str[i] == c)
    269.                 {
    270.                     return i;
    271.                 }
    272.             }
    273.  
    274.             return npos;
    275.         }
    276.  
    277.         // 返回子串s在string中第一次出现的位置
    278.  
    279.         size_t find(const char* s, size_t pos = 0) const
    280.         {
    281.             assert(pos < _size);
    282.  
    283.             const char* ptr = strstr(_str + pos, s);
    284.             if (ptr)
    285.             {
    286.                 return ptr - _str;
    287.             }
    288.             else
    289.             {
    290.                 return npos;
    291.             }
    292.         }
    293.  
    294.         // 在pos位置上插入字符c/字符串str，并返回该字符的位置
    295.  
    296.         void insert(size_t pos,size_t n, char c)
    297.         {
    298.             assert(pos < _size);
    299.             if (_size + n > _capacity)
    300.             {
    301.                 reserve(_size + n);
    302.             }
    303.             size_t end = _size;
    304.             while (end >= pos && end != npos)
    305.             {
    306.                 _str[end + n] = _str[end];
    307.                 --end;
    308.             }
    309.  
    310.             for (size_t i = 0; i < n; i++)
    311.             {
    312.                 _str[pos + i] = c;
    313.             }
    314.  
    315.             _size += n;
    316.         }
    317.  
    318.         void insert(size_t pos, const char* str)
    319.         {
    320.             assert(pos < _size);//判断pos位置的合法性
    321.             size_t len = strlen(str);//获取字符串长度，方便后续操作
    322.             if (_size + len> _capacity)//判断是否需要扩容
    323.             {
    324.                 reserve(_size + len);
    325.             }
    326.             size_t end = _size;
    327.             while (end >= pos && end != npos)//移动元素
    328.             {
    329.                 _str[end + len] = _str[end];
    330.                 --end;
    331.             }
    332.  
    333.             for (size_t i = 0; i < len; i++)//写入元素
    334.             {
    335.                 _str[pos + i] = str[i];
    336.             }
    337.  
    338.             _size += len;
    339.         }
    340.         // 删除pos位置上的元素，并返回该元素的下一个位置
    341.  
    342.         void erase(size_t pos, size_t len=npos)
    343.         {
    344.             assert(pos < _size);//判断pos位置的合法性
    345.             if (len == npos || pos + len > _size)
    346.             {
    347.                 _str[pos] = '\0';
    348.                 _size = pos;
    349.             }
    350.             else
    351.             {
    352.                 size_t end = pos + len;
    353.                 while (end <= _size)
    354.                 {
    355.                     _str[pos++] = _str[end++];
    356.                 }
    357.                 _size = _size - len;
    358.             }
    359.         }
    360.         string substr(size_t pos = 0, size_t len = npos)
    361.         {
    362.             assert(pos < _size);
    363.  
    364.             size_t n = len;
    365.             if (len == npos || pos + len > _size)
    366.             {
    367.                 n = _size - pos;
    368.             }
    369.  
    370.             string tmp;
    371.             tmp.reserve(n);
    372.             for (size_t i = pos; i < pos + n; i++)
    373.             {
    374.                 tmp += _str[i];
    375.             }
    376.  
    377.             return tmp;
    378.         }
    379.  
    380.     private:
    381.  
    382.         char* _str;
    383.  
    384.         size_t _capacity;
    385.  
    386.         size_t _size;
    387.         const static size_t npos;
    388.     };
    389.    const  size_t string::npos = -1;
    390.    ostream& operator<<(ostream& out, const string& s)
    391.    {
    392.        for (auto ch : s)
    393.        {
    394.            out << ch;
    395.        }
    396.        return out;
    397.    }
    398.    istream& operator>>(istream& _cin, xhj::string& s)
    399.    {
    400.        char ch = _cin.get();
    401.        s.clear();//为了每次达到输入后覆盖的效果
    402.        char buff[128];//这里使用数组首先是避免了每次+=造成的多次开辟空间而导致效率上的降低
    403.                        //其次避免了我们预先在堆上开辟大量空间而可能造成空间浪费的情况
    404.        //清理缓冲区
    405.        while (ch == ' ' || ch == '\n')
    406.        {
    407.            ch = _cin.get();
    408.        }
    409.        int i = 0;
    410.        while (ch != ' ' && ch != '\n')
    411.        {
    412.            buff[i++] = ch;
    413.            if (i == 127)
    414.            { 
    415.                buff[i] = '\0';
    416.                s += buff;
    417.                i = 0;
    418.            }
    419.            ch = _cin.get();
    420.        }
    421.        if (i != 0)
    422.        {
    423.            buff[i] = '\0';
    424.            s += buff;
    425.        }
    426.        return _cin;
    427.    }
    428.    
    429. };
  • 相关阅读:
    代码随想录算法训练营第六天 |18. 四数之和、344.反转字符串、541. 反转字符串II
    利用Selenium实现图片文件上传的两种方式介绍
    基础IO(文件读取写入，重定向，缓冲区)
    牛客网C语言刷题（指针篇）
    Linux安装OpenCV——利用包管理器apt从源仓库安装（绝对是最简单的安装方法）
    【计算机视觉（7）】
    分类算法-下
    Deepwalk，Node2vec算法原理生动理解（图文）
    云原生超融合八大核心能力｜ZStack Edge云原生超融合产品技术解读
    为 Serverless Devs 插上 Terraform 的翅膀，实现企业级多环境部署（下）
  • 原文地址：https://blog.csdn.net/weixin_68624665/article/details/133500814