0
0

【C++学习手札】模拟实现string

    1.                                                 ***🎬慕斯主页***：*修仙—别有洞天**
    3.                                                  ♈️*今日夜电波：缶ビール—みゆな*
    5.                                                           0:41━━━━━━️💟──────── 2:52
    6.                                                                🔄   ◀️   ⏸   ▶️    ☰ 
    8.                                 💗关注👍点赞🙌收藏*您的每一次鼓励都是对我莫大的支持*😍

一、string实际的底层原理

  1.     ***string类型底层实现通常使用动态数组***，因为它允许在运行时动态分配内存空间。这使得字符串的长度可以根据需要进行调整，而不需要提前分配固定大小的空间，并且可以避免缓冲区溢出和内存泄漏等问题。 string类型还提供了各种字符串操作函数，例如拼接、查找、替换、大小写转换等。
  • 底层实际的储存结构：*
  1. class string
  2. {
  4. private:
  6.     char* _str;
  8.     size_t _capacity;
  10.     size_t _size;
  12. };

二、string的模拟实现

基本成员函数

** 构造函数 **

  1.     通过设置缺省参数以及初始化列表来默认构造string对象
  1. string(const char* str = "")
  2.             :_size(strlen(str))
  3.             ,_capacity(_size)
  4.         {
  5.             _str = new char[_capacity + 1];
  6.             strcpy(_str, str);
  7.         }
  1.     在模拟实现string的构造函数时，很多人包括作者我一开始都会想着将他分为有参以及无参两部分，但是这种做法是会产生一定的问题的，如下为作者写出的错误的代码：
  1. class string
  2.     {
  4.     public:
  5.         string()//无参构造函数
  6.             //初始化列表
  7.             :_str(nullptr)
  8.             , _size(0)
  9.             , _capacity(0)
  10.         {
  12.         }
  13.         string(char* str)//带参构造函数->char a[] = "abc";string kk(a)
  14.             :_str(str),
  15.             _size(strlen(str)),
  16.             _capacity(strlen(str))
  17.         {
  19.         }
  21.         string(const char* str)//带参构造函数->string kk("abc")
  22.             :_str(str),
  23.             _size(strlen(str)),
  24.             _capacity(strlen(str))
  25.         {
  27.         }
  28.     private:
  30.         char* _str;
  32.         size_t _capacity;
  34.         size_t _size;
  36.     };
  1.     对于以上代码，若调用如上的带参构造函数中string(const char* str)就会报错，因为str传给_str属于权限放大，现在有两种解决方法，**一种是将它改为 string(char* str)，但是这样就不能直接传递字符串，需要先生成字符串，还有一种方法是将_str改为const char*类型，但是此时就不能修改_str指向的内容，后续的一些操作会出现一些错误**。

拷贝构造函数

  1.     由于我们使用了开辟了空间来用于储存数据，因此我们需要进行深拷贝，防止对于另外一个对象的影响。
  1.     *传统写法： *
  1.     开辟对应的空间，然后再给相应的值。
  1.         // 传统写法
  2.         // s2(s1)
  3.         //string(const string& s)
  4.         //{
  5.         //    _str = new char[s._capacity+1];
  6.         //    strcpy(_str, s._str);
  7.         //    _size = s._size;
  8.         //    _capacity = s._capacity;
  9.         //}
  1.    * 较为推荐的写法：*
  1.     通过让构造函数帮我们创建一个构造相应的字符的对象，然后我们再交换两个对象的数据即可得。
  1. void swap(string& s)
  2.         {
  3.             std::swap(_str, s._str);
  4.             std::swap(_size, s._size);
  5.             std::swap(_capacity, s._capacity);
  6.         }
  8.         string(const string& s)
  9.             :_str(nullptr)
  10.             ,_size(0)
  11.             ,_capacity(0)
  12.         {
  13.             string tmp(s._str);
  14.             swap(tmp);
  15.         }

析构函数

  1.     避免内存泄漏需要自己写一个析构函数用以销毁new在堆区所创建的空间 
  1.         ~string()
  2.         {
  3.             delete[]_str;
  4.             _str = nullptr;
  5.             _size = _capacity = 0;
  6.         }

**重载赋值运算符 **

** ** 同上面的拷贝构造函数一样，我们对此也是需要深拷贝的

    1.    传统写法： *
  1.     开辟对应的空间，然后再给相应的值。
  1.         //string& operator=(const string& s)
  2.         //{
  3.         //    if (this != &s)
  4.         //    {
  5.         //        char* tmp = new char[s._capacity + 1];
  6.         //        strcpy(tmp, s._str);
  8.         //        delete[] _str;
  9.         //        _str = tmp;
  10.         //        _size = s._size;
  11.         //        _capacity = s._capacity;
  12.         //    }
  14.         //    return *this;
  15.         //}
    1.    较为推荐的写法：*
  1.     通过让构造函数帮我们创建一个构造相应的字符的对象，然后我们再交换两个对象的数据即可得。
  2.         string& operator=(const string& s)
  3.         {
  4.             if (this != &s)
  5.             {
  6.                 string tmp(s);
  7.                 //this->swap(tmp);
  8.                 swap(tmp);
  9.             }
  11.             return *this;
  12.         }
  1.     再简化一点：通过在传值时进行拷贝构造，然后交换数据。
  1. string& operator=(string tmp)
  2.         {
  3.             swap(tmp);
  5.             return *this;
  6.         }

** 迭代器**

迭代器的概念

  1.      C++迭代器是一种用于遍历容器中元素的对象，它提供了一种统一的接口，使得不同类型的容器都可以使用相同的方式进行遍历。迭代器可以指向容器中的某个元素，并用于访问该元素的值或者进行修改。迭代器通常是一个类，它重载了指针操作符（*和->），以及自增（++）和自减（--）运算符，使得迭代器可以像指针一样进行移动。
  3.     ***string的迭代器实际实现原理：***
  5.    ** string的迭代器实际上是一个指向string底层存储空间中char类型数据的指针，不同的迭代器类型标志着不同的访问权限。例如，一个string::iterator对象可以用来读写字符，而一个const string::iterator对象只能用来读取字符。**
  1.     *于是我们定义出以下的迭代器：*
  1.         typedef char* iterator;
  2.         typedef const char* const_iterator;

** begin（）**

  1.     用于返回第一个字符的地址。
  1.         iterator begin()
  2.         {
  3.             return _str; 
  4.         }
  5.         const_iterator begin()const
  6.         {
  7.             return _str; 
  8.         }

** end（）**

  1.     用于返回后一个字符的后一个字符的地址的地址。其实就是‘\0’的地址
  1.         iterator begin()
  2.         {
  3.             return _str; 
  4.         }
  5.         const_iterator begin()const
  6.         {
  7.             return _str; 
  8.         }

空间管理

  1.         size_t size()const//大小
  2.         {
  3.             return _size;
  4.         }
  6.         size_t capacity()const//空间
  7.         {
  8.             return _capacity;
  9.         }
  11.         bool empty()const//空？
  12.         {
  13.             return _size == 0;
  14.         }
  16.         void reserve(size_t n)//扩容
  17.         {
  18.             if (n > _capacity)
  19.             {
  20.                 char* tmp = new char[n + 1];
  21.                 strcpy(tmp, _str);
  22.                 delete[]_str;
  24.                 _str = tmp;
  25.                 _capacity = n;
  26.             }
  27.         }
  29.         void resize(size_t n, char c = '\0')//重设大小
  30.         {
  31.             if (n <= _size)
  32.             {
  33.                 _str[n] = '\0';
  34.                 _size = n;
  35.             }
  36.             else 
  37.             {
  38.                 reserve(n);
  39.                 while (_size < n)
  40.                 { 
  41.                     _str[_size] = c ;
  42.                     ++_size;
  43.                 }
  45.                 _str[_size] = '\0';
  46.             }
  47.         }

修改相关

** push_back（）**

  1.      根据原型可知此函数是在当前字符串尾插一个字符，其中需要额外注意容量。
  1.         void push_back(char c)
  2.         {
  3.             if (_size == _capacity)
  4.             {
  5.                 reserve(_capacity == 0 ? 4 : _capacity * 2);
  6.             }
  8.             _str[_size] = c;
  9.             ++_size;
  10.             _str[_size] = '\0';
  11.         }

** append （）**

  1.      根据原型可知此函数有很多的函数重载，但是我们最常用的就是尾插一段字符串，对此就不过多进行阐述。也需要额外注意容量。
  1.         void append(const char* str)
  2.         {
  3.             size_t len = strlen(str);
  4.             if (_size + len > _capacity)
  5.             {
  6.                 reserve(_size + len);
  7.             }
  9.             strcpy(_str + _size, str);//拷贝到原字符串后
  10.             _size += len;
  11.         }

** 重载+=运算符**

  1.      此处复用了以上的push_back和append函数，这也是根据C++中函数管用的复用习惯来做出的选择。
  1.  string& operator+=(char c)
  2.         {
  3.             push_back(c);
  4.         }
  6.         string& operator+=(const char* str)
  7.         {
  8.             append(str);
  10.             return *this;
  11.         }

c_str （）

  1.     返回指向数组的指针，该数组包含以 null 结尾的字符序列（即 C 字符串），该字符表示字符串对象的当前值。简而言之就是将string对象转换为C语言风格类型的字符串。
  1.         const char* c_str()const
  2.         {
  3.             return _str;
  4.         }

** clear（）**

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

** swap（）**

  1.         void swap(string& s)
  2.         {
  3.             std::swap(_str, s._str);
  4.             std::swap(_size, s._size);
  5.             std::swap(_capacity, s._capacity);
  6.         }

** 重载[ ]（最爱的运算符！！！）**

  1.     这里其实就是按照数组的相关操作即可，但是要注意越界的判断！
  1.         char& operator[](size_t index)
  2.         {
  3.             assert(index < _size);
  5.             return _str[index];
  6.         }
  8.         const char& operator[](size_t index)const
  9.         {
  10.             assert(index < _size);
  12.             return _str[index];
  13.         }

关系运算符的重载

  1.     关系运算符的重载的关键就是根据所需进行相应的数据变化以及做出值的返回。 
  1.         bool operator<(const string& s) const
  2.         {
  3.             return strcmp(_str, s._str) < 0;
  4.         }
  6.         bool operator==(const string& s) const
  7.         {
  8.             return strcmp(_str, s._str) == 0;
  9.         }
  11.         bool operator<=(const string& s) const
  12.         {
  13.             return *this < s || *this == s;
  14.         }
  16.         bool operator>(const string& s) const
  17.         {
  18.             return !(*this <= s);
  19.         }
  21.         bool operator>=(const string& s) const
  22.         {
  23.             return !(*this < s);
  24.         }
  26.         bool operator!=(const string& s) const
  27.         {
  28.             return !(*this == s);
  29.         }

基本操作

** 查找find（） **

  1.     由原型知，分为按照字符查找以及字符串查找还有常量字符串查找，对此，此次实现字符以及字符串查找。
    1.    对于字符查找： *
  1.         size_t find(char c, size_t pos = 0) const
  2.         {
  3.             for (size_t i = pos; i < _size; i++)
  4.             {
  5.                 if (_str[i] == c)
  6.                 {
  7.                     return i;
  8.                 }
  9.             }
  11.             return npos;
  12.         }
  1.     *对于字符串查找： *
*** 前置知识substr（）***

  1.      他的主要作用就是在str中从pos位置开始，截取n个字符，然后将其返回。***其中的npos实际上是一个全局的静态变量，实际的赋值为-1，都是由于类型为size_t，因此实际上为最大值！***
  1.         string substr(size_t pos, size_t len = npos)
  2.         {
  3.             string s;
  4.             size_t end = pos + len;
  5.             if (len == npos || pos + len >= _size) // 有多少取多少
  6.             {
  7.                 len = _size - pos;
  8.                 end = _size;
  9.             }
  11.             s.reserve(len);
  12.             for (size_t i = pos; i < end; i++)
  13.             {
  14.                 s += _str[i];
  15.             }
  17.             return s;
  18.         }
  20.         // 返回子串s在string中第一次出现的位置
  21.         size_t find(const char* s, size_t pos = 0) const
  22.         {
  23.             const char* p = strstr(_str + pos, s);
  24.             if (p)
  25.             {
  26.                 return p - _str;
  27.             }
  28.             else
  29.             {
  30.                 return npos;
  31.             }
  32.         }

** 插入insert（）**

  1.     根据所插入的空间大小挪字符
  2.         void insert(size_t pos, char ch)
  3.         {
  4.             assert(pos <= _size);
  5.             if (_size == _capacity)
  6.             {
  7.                 reserve(_capacity == 0 ? 4 : _capacity * 2);
  8.             }
  10.             size_t end = _size + 1;
  11.             while (end > pos)
  12.             {
  13.                 _str[end] = _str[end - 1];
  14.                 --end;
  15.             }
  17.             _str[pos] = ch;
  18.             _size++;
  19.         }
  21.         void insert(size_t pos, const char* str)
  22.         {
  23.             assert(pos <= _size);
  25.             size_t len = strlen(str);
  26.             if (_size + len > _capacity)
  27.             {
  28.                 reserve(_size + len);
  29.             }
  31.             // 挪动数据
  32.             int end = _size;
  33.             while (end >= (int)pos)
  34.             {
  35.                 _str[end + len] = _str[end];
  36.                 --end;
  37.             }
  39.             strncpy(_str + pos, str, len);
  40.             _size += len;
  41.         }

** 删除 erase（）**

  1.      删除指定位置的字符，可根据调节删除的数量，默认是指定位置以后全删。
  1.         void erase(size_t pos, size_t len = npos)
  2.         {
  3.             assert(pos < _size);
  5.             if (len == npos || pos + len >= _size)
  6.             {
  7.                 _str[pos] = '\0';
  8.                 _size = pos;
  9.             }
  10.             else
  11.             {
  12.                 size_t begin = pos + len;
  13.                 while (begin <= _size)
  14.                 {
  15.                     _str[begin - len] = _str[begin];
  16.                     ++begin;
  17.                 }
  18.                 _size -= len;
  19.             }
  20.         }

流插入流提取

  1.      重载<<和>>是为了能够像内置一样调用，输入打印。
  1. ostream& operator<<(ostream& out, const string& s)
  2. {
  3.     /*for (size_t i = 0; i < s.size(); i++)
  4.     {
  5.         out << s[i];
  6.     }*/
  7.     for (auto ch : s)
  8.         out << ch;
  10.     return out;
  11. }
  13. istream& operator>>(istream& in, string& s)
  14. {
  16.     s.clear();
  18.     char buff[129];
  19.     size_t i = 0;
  21.     char ch;
  22.     ch = in.get();
  23.     while (ch != ' ' && ch != '\n')
  24.     {
  25.         buff[i++] = ch;
  26.         if (i == 128)
  27.         {
  28.             buff[i] = '\0';
  29.             s += buff;
  30.             i = 0;
  31.         }
  33.         //s += ch;
  35.         ch = in.get();
  36.     }
  38.     if (i != 0)
  39.     {
  40.         buff[i] = '\0';
  41.         s += buff;
  42.     }
  44.     return in;
  45. }

总体代码

  1. #pragma once
  2. #define _CRT_SECURE_NO_WARNINGS 01
  3. #include<iostream>
  4. #include<assert.h>
  5. using namespace std;
  7. namespace lt
  8. {
  9.     class string
  10.     {
  11.     public:
  12.         typedef char* iterator;
  13.         typedef const char* const_iterator;
  15.         friend ostream& operator<<(ostream& out, const string& s);
  16.         friend istream& operator>>(istream& in, string& s);
  17.         iterator begin()
  18.         {
  19.             return _str;
  20.         }
  22.         iterator end()
  23.         {
  24.             return _str + _size;
  25.         }
  27.         const_iterator begin() const
  28.         {
  29.             return _str;
  30.         }
  32.         const_iterator end() const
  33.         {
  34.             return _str + _size;
  35.         }
  37.         /*string()
  38.             :_str(new char[1]{'\0'})
  39.             ,_size(0)
  40.             ,_capacity(0)
  41.         {}*/
  43.         string(const char* str = "")
  44.             :_size(strlen(str))
  45.             , _capacity(_size)
  46.         {
  47.             _str = new char[_capacity + 1];
  48.             strcpy(_str, str);
  49.         }
  51.         // 传统写法
  52.         // s2(s1)
  53.         //string(const string& s)
  54.         //{
  55.         //    _str = new char[s._capacity+1];
  56.         //    strcpy(_str, s._str);
  57.         //    _size = s._size;
  58.         //    _capacity = s._capacity;
  59.         //}
  61.          s2 = s3
  62.         //string& operator=(const string& s)
  63.         //{
  64.         //    if (this != &s)
  65.         //    {
  66.         //        char* tmp = new char[s._capacity + 1];
  67.         //        strcpy(tmp, s._str);
  69.         //        delete[] _str;
  70.         //        _str = tmp;
  71.         //        _size = s._size;
  72.         //        _capacity = s._capacity;
  73.         //    }
  75.         //    return *this;
  76.         //}
  78.         void swap(string& s)
  79.         {
  80.             std::swap(_str, s._str);
  81.             std::swap(_size, s._size);
  82.             std::swap(_capacity, s._capacity);
  83.         }
  85.         // s2(s1)
  86.         string(const string& s)
  87.             :_str(nullptr)
  88.             , _size(0)
  89.             , _capacity(0)
  90.         {
  91.             string tmp(s._str);
  92.             swap(tmp);
  93.         }
  95.         // s2 = s3
  96.         //string& operator=(const string& s)
  97.         //{
  98.         //    if (this != &s)
  99.         //    {
  100.         //        string tmp(s);
  101.         //        //this->swap(tmp);
  102.         //        swap(tmp);
  103.         //    }
  105.         //    return *this;
  106.         //}
  108.         // s2 = s3
  109.         string& operator=(string tmp)
  110.         {
  111.             swap(tmp);
  113.             return *this;
  114.         }
  116.         ~string()
  117.         {
  118.             delete[] _str;
  119.             _str = nullptr;
  120.             _size = _capacity = 0;
  121.         }
  123.         char& operator[](size_t pos)
  124.         {
  125.             assert(pos < _size);
  127.             return _str[pos];
  128.         }
  130.         const char& operator[](size_t pos) const
  131.         {
  132.             assert(pos < _size);
  134.             return _str[pos];
  135.         }
  137.         size_t capacity() const
  138.         {
  139.             return _capacity;
  140.         }
  142.         size_t size() const
  143.         {
  144.             return _size;
  145.         }
  147.         const char* c_str() const
  148.         {
  149.             return _str;
  150.         }
  152.         void reserve(size_t n)
  153.         {
  154.             if (n > _capacity)
  155.             {
  156.                 char* tmp = new char[n + 1];
  157.                 strcpy(tmp, _str);
  158.                 delete[] _str;
  159.                 _str = tmp;
  161.                 _capacity = n;
  162.             }
  163.         }
  165.         void resize(size_t n, char ch = '\0')
  166.         {
  167.             if (n <= _size)
  168.             {
  169.                 _str[n] = '\0';
  170.                 _size = n;
  171.             }
  172.             else
  173.             {
  174.                 reserve(n);
  175.                 while (_size < n)
  176.                 {
  177.                     _str[_size] = ch;
  178.                     ++_size;
  179.                 }
  181.                 _str[_size] = '\0';
  182.             }
  183.         }
  185.         size_t find(char ch, size_t pos = 0)
  186.         {
  187.             for (size_t i = pos; i < _size; i++)
  188.             {
  189.                 if (_str[i] == ch)
  190.                 {
  191.                     return i;
  192.                 }
  193.             }
  195.             return npos;
  196.         }
  198.         size_t find(const char* sub, size_t pos = 0)
  199.         {
  200.             const char* p = strstr(_str + pos, sub);
  201.             if (p)
  202.             {
  203.                 return p - _str;
  204.             }
  205.             else
  206.             {
  207.                 return npos;
  208.             }
  209.         }
  211.         string substr(size_t pos, size_t len = npos)
  212.         {
  213.             string s;
  214.             size_t end = pos + len;
  215.             if (len == npos || pos + len >= _size) // 有多少取多少
  216.             {
  217.                 len = _size - pos;
  218.                 end = _size;
  219.             }
  221.             s.reserve(len);
  222.             for (size_t i = pos; i < end; i++)
  223.             {
  224.                 s += _str[i];
  225.             }
  227.             return s;
  228.         }
  230.         void push_back(char ch)
  231.         {
  232.             if (_size == _capacity)
  233.             {
  234.                 reserve(_capacity == 0 ? 4 : _capacity * 2);
  235.             }
  237.             _str[_size] = ch;
  238.             ++_size;
  239.             _str[_size] = '\0';
  240.         }
  242.         void append(const char* str)
  243.         {
  244.             size_t len = strlen(str);
  245.             if (_size + len > _capacity)
  246.             {
  247.                 reserve(_size + len);
  248.             }
  250.             strcpy(_str + _size, str);
  251.             _size += len;
  252.         }
  254.         string& operator+=(char ch)
  255.         {
  256.             push_back(ch);
  257.             return *this;
  258.         }
  260.         string& operator+=(const char* str)
  261.         {
  262.             append(str);
  263.             return *this;
  264.         }
  266.         void insert(size_t pos, char ch)
  267.         {
  268.             assert(pos <= _size);
  269.             if (_size == _capacity)
  270.             {
  271.                 reserve(_capacity == 0 ? 4 : _capacity * 2);
  272.             }
  274.             size_t end = _size + 1;
  275.             while (end > pos)
  276.             {
  277.                 _str[end] = _str[end - 1];
  278.                 --end;
  279.             }
  281.             _str[pos] = ch;
  282.             _size++;
  283.         }
  285.         void insert(size_t pos, const char* str)
  286.         {
  287.             assert(pos <= _size);
  289.             size_t len = strlen(str);
  290.             if (_size + len > _capacity)
  291.             {
  292.                 reserve(_size + len);
  293.             }
  295.             // 挪动数据
  296.             int end = _size;
  297.             while (end >= (int)pos)
  298.             {
  299.                 _str[end + len] = _str[end];
  300.                 --end;
  301.             }
  303.             strncpy(_str + pos, str, len);
  304.             _size += len;
  305.         }
  307.         void erase(size_t pos, size_t len = npos)
  308.         {
  309.             assert(pos < _size);
  311.             if (len == npos || pos + len >= _size)
  312.             {
  313.                 _str[pos] = '\0';
  314.                 _size = pos;
  315.             }
  316.             else
  317.             {
  318.                 size_t begin = pos + len;
  319.                 while (begin <= _size)
  320.                 {
  321.                     _str[begin - len] = _str[begin];
  322.                     ++begin;
  323.                 }
  324.                 _size -= len;
  325.             }
  326.         }
  328.         bool operator<(const string& s) const
  329.         {
  330.             return strcmp(_str, s._str) < 0;
  331.         }
  333.         bool operator==(const string& s) const
  334.         {
  335.             return strcmp(_str, s._str) == 0;
  336.         }
  338.         bool operator<=(const string& s) const
  339.         {
  340.             return *this < s || *this == s;
  341.         }
  343.         bool operator>(const string& s) const
  344.         {
  345.             return !(*this <= s);
  346.         }
  348.         bool operator>=(const string& s) const
  349.         {
  350.             return !(*this < s);
  351.         }
  353.         bool operator!=(const string& s) const
  354.         {
  355.             return !(*this == s);
  356.         }
  358.         void clear()
  359.         {
  360.             _str[0] = '\0';
  361.             _size = 0;
  362.         }
  363.     private:
  364.         char* _str;
  365.         size_t _size;
  366.         size_t _capacity;
  368.         //const static size_t npos = -1;  // 特例
  369.         //const static double npos = 1.1;  // 不支持
  370.     public:
  371.         const static size_t npos;
  372.     };
  374.     const size_t string::npos = -1;
  376.     ostream& operator<<(ostream& out, const string& s)
  377.     {
  378.         /*for (size_t i = 0; i < s.size(); i++)
  379.         {
  380.             out << s[i];
  381.         }*/
  382.         for (auto ch : s)
  383.             out << ch;
  385.         return out;
  386.     }
  388.     istream& operator>>(istream& in, string& s)
  389.     {
  390.         s.clear();
  391.         //s.reserve(128);
  393.         char buff[129];
  394.         size_t i = 0;
  396.         char ch;
  397.         ch = in.get();
  398.         while (ch != ' ' && ch != '\n')
  399.         {
  400.             buff[i++] = ch;
  401.             if (i == 128)
  402.             {
  403.                 buff[i] = '\0';
  404.                 s += buff;
  405.                 i = 0;
  406.             }
  408.             //s += ch;
  410.             ch = in.get();
  411.         }
  413.         if (i != 0)
  414.         {
  415.             buff[i] = '\0';
  416.             s += buff;
  417.         }
  419.         return in;
  420.     }
  422. }

** 感谢你耐心的看到这里ღ( ´･ᴗ･` )比心，如有哪里有错误请踢一脚作者o(╥﹏╥)o！** 

  1.                                    ![](https://img-blog.csdnimg.cn/a2296f4aa7fd45e9b1a1c44f9b8432a6.gif)

** 给个三连再走嘛~ **

标签： 学习 c++ stl
本文转载自: https://blog.csdn.net/weixin_64038246/article/details/134422860
版权归原作者 慕斯( ˘▽˘)っ 所有， 如有侵权，请联系我们删除。
登录后发布评论

“【C++学习手札】模拟实现string”的评论:

还没有评论
关于作者
...
overfit同步小助手
文章同步
相关阅读

网络安全法-网络运行安全

使用selenium/drissionpage时如何阻止chrome自动跳转http到https

docker desktop 里部署的Open WebUI 管理员密码忘记了的处理方法

在ubuntu20.04中搭建onsite比赛运行环境

利用开源的低代码表单设计器FcDesigner高效管理和渲染复杂表单结构

Kafka学习笔记

【前端】浏览器输入url到页面呈现发生了什么？