• 【C++】string的底层剖析以及模拟实现

    一、字符串类的认识

            C语言中，字符串是以'\0'结尾的一些字符的集合，为了操作方便，C标准库中提供了一些str系列的库函数， 但是这些库函数与字符串是分离开的，不太符合OOP的思想，而且底层空间需要用户自己管理，稍不留神可能还会越界访问。在OJ中，有关字符串的题目基本以string类的形式出现，而且在常规工作中，为了简单、方便、快捷，基本 都使用string类，很少有人去使用C库中的字符串操作函数。为了增加自己对于string的理解，自己将模仿库中string类有的方法，设计一个简单的string类。其中类成员包括以下：

    1. class string
    2.     {
    3.  
    4.     private:
    5.  
    6.         char* _str;//字符串首地址
    7.  
    8.         size_t _capacity;//字符串容量
    9.  
    10.         size_t _size;//有效数据的个数
    11.  
    12.     public:
    13.  
    14.         typedef char* iterator;
    15.     }

    二、库中string常用的方法

            我主要会实现string中经常会用到的方法，若大家想要了解更多关于string的细节，可以登录这个C++查询网站https://cplusplus.com/reference/自行查询。下面是一些常用方法以及代码片段，可能前面出现的方法会用到后面出现的方法的实现，若有疑问可以看最后面的完整代码

    正向迭代器

    1. iterator begin()
    2. {
    3.     return _str;
    4. }
    5.  
    6. iterator end()
    7. {
    8.     return _str + _size;
    9. }

    +=

    1.         string& operator+=(char c)
    2.         {
    3.             if (_size == _capacity)
    4.             {
    5.                 _capacity = _capacity == 0 ? 4 : 2 * _capacity;
    6.                 char* tmp = new char[_capacity +1];
    7.                 strcpy(tmp, _str);
    8.                 delete[] _str;
    9.                 _str = tmp;
    10.             }
    11.  
    12.             _str[_size] = c;
    13.             _str[_size + 1] = '\0';
    14.             _size++;
    15.  
    16.             return *this;
    17.         }
    18.  
    19.         string& operator+=(const char* str)
    20.         {
    21.             append(str);
    22.             return *this;
    23.         }

    push_back(尾插)

    1.         void push_back(char c)
    2.         {
    3.             *this += c;
    4.         }

     append（在字符串末尾追加）

    1.         void append(const char* str)
    2.         {
    3.             int i = 0;
    4.             while (str[i])
    5.             {
    6.                 push_back(str[i]);
    7.                 i++;
    8.             }
    9.         }

      clear（清除掉字符串的数据）

    1.         void clear()
    2.         {
    3.             _size = 0;
    4.             _str[0] = '\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.         }

      c_str（返回字符串的首地址）

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

     resize（将字符串设定为指定大小，字符串占满所开辟的空间）

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

     reserve（预开辟出空间，字符串还是原来的大小（一般不缩容））

    1.         void reserve(size_t n)
    2.         {
    3.             if (n > _capacity)
    4.             {
    5.                 _capacity = n;
    6.                 char* tmp = new char[_capacity + 1];
    7.                 strcpy(tmp, _str);
    8.                 delete[] _str;
    9.                 _str = tmp;
    10.             }
    11.         }

      find（返回字符c在string中第一次出现的位置/返回子串s在string中第一次出现的位置）

    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.                     return i;
    7.             }
    8.             return std::string::npos;
    9.         }
    10.         size_t find(const char* s, size_t pos = 0) const
    11.         {
    12.             const char* ptr = std::strstr(_str + pos, s);
    13.  
    14.             if (ptr == nullptr)
    15.                 return std::string::npos;
    16.             else
    17.             {
    18.                 return ptr - _str;
    19.             }
    20.         }

    insert（在pos位置上插入字符c/字符串str，并返回该字符的位置）

     

    1.         string& insert(size_t pos, char c)
    2.         {
    3.             if (_size == _capacity)
    4.             {
    5.                 reserve(_capacity == 0 ? 4 : 2 * _capacity);
    6.             }
    7.             size_t end = _size - 1;
    8.             while (end >= pos)
    9.             {
    10.                 _str[end + 1] = _str[end];
    11.                 end--;
    12.             }
    13.             _str[pos] = c;
    14.             return *this;
    15.         }
    16.  
    17.         string& insert(size_t pos, const char* str)
    18.         {
    19.             int len = 0;
    20.             while (str[len++]);
    21.             if (_size + len > _capacity)
    22.             {
    23.                 reserve(_size + len);
    24.             }
    25.  
    26.             memmove(_str + pos + len, _str + pos, len * sizeof(char));
    27.  
    28.             for (int i = pos; i < pos + len; i++)
    29.             {
    30.                 _str[i] = str[i - pos];
    31.             }
    32.             _size += len;
    33.             return *this;
    34.         }

    erase（删除pos位置上的元素，并返回该string）

    1.         string& erase(size_t pos, size_t len)
    2.         {
    3.             memmove(_str + pos, _str + pos + len, (_size - pos-len) * sizeof(char));
    4.             _size -= len;
    5.             return *this;
    6.         }

    三、完整代码

    1. //string.h
    2. #pragma once
    3. #define _CRT_SECURE_NO_WARNINGS 1
    4. #include 
    5. #include 
    6. //using namespace std;
    7.  
    8. namespace sxb
    9. {
    10.  
    11.     class string
    12.     {
    13.  
    14.         friend std::ostream& operator<<(std::ostream& _cout, const string& s);
    15.  
    16.         friend std::istream& operator>>(std::istream& _cin, string& s);
    17.     private:
    18.  
    19.         char* _str;
    20.  
    21.         size_t _capacity;
    22.  
    23.         size_t _size;
    24.  
    25.     public:
    26.  
    27.         typedef char* iterator;
    28.  
    29.     public:
    30.  
    31.         string(const char* str = "")
    32.         {
    33.             //_str = str;
    34.             int len = 0;
    35.             while(str[len] != ' ' && str[len] != '\0')
    36.             {
    37.                 len++;
    38.             }
    39.             _str = new char[len + 1];
    40.             for (int i = 0; i < len; i++)
    41.             {
    42.                 _str[i] = str[i];
    43.             }
    44.             _str[len] = '\0';
    45.             _capacity = len;
    46.             _size = len;
    47.         }
    48.  
    49.         string(const string& s)
    50.         {
    51.             _str = new char[s.size() + 1];
    52.             strcpy(_str, s.c_str());
    53.             _str[s.size()] = '\0';
    54.             _capacity = s.size();
    55.             _size = s.size();
    56.         }
    57.  
    58.         string& operator=(const string& s)
    59.         {
    60.             for (int i = 0; i < size(); i++)
    61.             {
    62.                 _str += s[i];
    63.             }
    64.             return *this;
    65.         }
    66.  
    67.         ~string()
    68.         {
    69.             delete[] _str;
    70.             _size = 0;
    71.             _capacity = 0;
    72.         }
    73.  
    74.  
    75.  
    76.             //
    77.  
    78.             // iterator
    79.  
    80.         iterator begin()
    81.         {
    82.             return _str;
    83.         }
    84.  
    85.         iterator end()
    86.         {
    87.             return _str + _size;
    88.         }
    89.  
    90.  
    91.  
    92.         //    /
    93.  
    94.         //    // modify
    95.  
    96.         void push_back(char c)
    97.         {
    98.             *this += c;
    99.         }
    100.  
    101.         string& operator+=(char c)
    102.         {
    103.             if (_size == _capacity)
    104.             {
    105.                 _capacity = _capacity == 0 ? 4 : 2 * _capacity;
    106.                 char* tmp = new char[_capacity +1];
    107.                 strcpy(tmp, _str);
    108.                 delete[] _str;
    109.                 _str = tmp;
    110.             }
    111.  
    112.             _str[_size] = c;
    113.             _str[_size + 1] = '\0';
    114.             _size++;
    115.  
    116.             return *this;
    117.         }
    118.  
    119.         void append(const char* str)
    120.         {
    121.             int i = 0;
    122.             while (str[i])
    123.             {
    124.                 push_back(str[i]);
    125.                 i++;
    126.             }
    127.         }
    128.  
    129.         string& operator+=(const char* str)
    130.         {
    131.             append(str);
    132.             return *this;
    133.         }
    134.  
    135.         void clear()
    136.         {
    137.             _size = 0;
    138.             _str[0] = '\0';
    139.         }
    140.  
    141.         void swap(string& s)
    142.         {
    143.             std::swap(_str,s._str);
    144.             std::swap(_size, s._size);
    145.             std::swap(_capacity, s._capacity);
    146.         }
    147.  
    148.         const char* c_str()const
    149.         {
    150.             return _str;
    151.         }
    152.  
    153.  
    154.  
    155.         ///
    156.  
    157.          capacity
    158.  
    159.         size_t size()const
    160.         {
    161.             return _size;
    162.         }
    163.  
    164.         size_t capacity()const
    165.         {
    166.             return _capacity;
    167.         }
    168.  
    169.         bool empty()const
    170.         {
    171.             return _str[0] == '\0';
    172.         }
    173.  
    174.         void resize(size_t n, char c = '\0')
    175.         {
    176.             if (n > _capacity)
    177.             {
    178.                 reserve(n);
    179.                 for (int i = _size; i < _capacity; i++)
    180.                 {
    181.                     _str[i] = c;
    182.                 }
    183.                 _size = _capacity;
    184.             }
    185.             else
    186.             {
    187.                 _size = n;
    188.             }
    189.         }
    190.  
    191.         void reserve(size_t n)
    192.         {
    193.             if (n > _capacity)
    194.             {
    195.                 _capacity = n;
    196.                 char* tmp = new char[_capacity + 1];
    197.                 strcpy(tmp, _str);
    198.                 delete[] _str;
    199.                 _str = tmp;
    200.             }
    201.         }
    202.  
    203.  
    204.  
    205.         ///
    206.  
    207.          access
    208.  
    209.         char& operator[](size_t index)
    210.         {
    211.             return _str[index];
    212.         }
    213.  
    214.         const char& operator[](size_t index)const
    215.         {
    216.             return _str[index];
    217.         }
    218.  
    219.  
    220.  
    221.         ///
    222.  
    223.         relational operators
    224.  
    225.         bool operator==(const string& s)
    226.         {
    227.             if (_size != s.size())
    228.                 return false;
    229.             for (int i = 0; i < _size; i++)
    230.             {
    231.                 if (_str[i] != s[i])
    232.                     return false;
    233.             }
    234.             return true;
    235.         }
    236.  
    237.         bool operator!=(const string& s)
    238.         {
    239.             return !operator==(s);
    240.         }
    241.  
    242.  
    243.  
    244.          返回c在string中第一次出现的位置
    245.  
    246.         size_t find(char c, size_t pos = 0) const
    247.         {
    248.             for (size_t i = pos; i < _size; i++)
    249.             {
    250.                 if (_str[i] == c)
    251.                     return i;
    252.             }
    253.             return std::string::npos;
    254.         }
    255.  
    256.          返回子串s在string中第一次出现的位置
    257.  
    258.         size_t find(const char* s, size_t pos = 0) const
    259.         {
    260.             const char* ptr = std::strstr(_str + pos, s);
    261.  
    262.             if (ptr == nullptr)
    263.                 return std::string::npos;
    264.             else
    265.             {
    266.                 return ptr - _str;
    267.             }
    268.         }
    269.  
    270.          在pos位置上插入字符c/字符串str，并返回该字符的位置
    271.  
    272.         string& insert(size_t pos, char c)
    273.         {
    274.             if (_size == _capacity)
    275.             {
    276.                 reserve(_capacity == 0 ? 4 : 2 * _capacity);
    277.             }
    278.             size_t end = _size - 1;
    279.             while (end >= pos)
    280.             {
    281.                 _str[end + 1] = _str[end];
    282.                 end--;
    283.             }
    284.             _str[pos] = c;
    285.             return *this;
    286.         }
    287.  
    288.         string& insert(size_t pos, const char* str)
    289.         {
    290.             int len = 0;
    291.             while (str[len++]);
    292.             if (_size + len > _capacity)
    293.             {
    294.                 reserve(_size + len);
    295.             }
    296.  
    297.             memmove(_str + pos + len, _str + pos, len * sizeof(char));
    298.  
    299.             for (int i = pos; i < pos + len; i++)
    300.             {
    301.                 _str[i] = str[i - pos];
    302.             }
    303.             _size += len;
    304.             return *this;
    305.         }
    306.  
    307.  
    308.  
    309.          删除pos位置上的元素，并返回该元素的下一个位置
    310.  
    311.         string& erase(size_t pos, size_t len)
    312.         {
    313.             memmove(_str + pos, _str + pos + len, (_size - pos-len) * sizeof(char));
    314.             _size -= len;
    315.             return *this;
    316.         }
    317.  
    318.  
    319.  
    320.     };
    321.  
    322.     std::ostream& operator<<(std::ostream& _cout, const string& s)
    323.     {
    324.         for (int i = 0; i < s.size(); i++)
    325.         {
    326.             _cout << s[i];
    327.         }
    328.         return _cout;
    329.     }
    330.  
    331.     std::istream& operator>>(std::istream& _cin, string& s)
    332.     {
    333.         char buffer[128];
    334.         int len = 0;
    335.         char bu = _cin.get();
    336.         while (bu != ' ' && bu != '\n')
    337.         {
    338.             buffer[len] = bu;
    339.             len++;
    340.             bu = _cin.get();
    341.         }
    342.  
    343.         for (int i = 0; i < len; i++)
    344.         {
    345.             s += buffer[i];
    346.         }
    347.  
    348.         return _cin;
    349.     }
    350.  
    351. }

  • 相关阅读:
    Nginx实战
    ACM练习——第四天
    2022-10-19 mysql列存储引擎-exists子查询错误-问题定位分析
    【案例分享】IPSec VPN与NQA联动实现主备对等体和主备链路快速切换
    第十一章：Java集合
    基于springboot农机电招平台设计与实现的源码+文档
    RepViT: 从ViT视角重新审视移动CNN
    Day711. 档案类-Java8后最重要新特性
    【多级缓存】
    模仿学习(DMP与GMM应用)
  • 原文地址：https://blog.csdn.net/m0_74265792/article/details/136693513