• C++ STL - string 成员函数 + 模拟实现

    目录

    string - 构造函数

     简介：

    分析：

    验证：

    string - 析构函数，重载赋值运算符

    ​编辑分析：

    模拟实现string构造，拷贝构造，重载赋值运算符，析构

    构造： 

    拷贝构造+重载赋值运算符

    传统写法：

    现代写法：

    string - Element access:

    前言：

    析：

    实现：

    string - 迭代器iterator

    简介：

    介绍：

    使用：

    string - 大小，容量函数

    string - 修改string操作

    string - 其余操作

    完整tiny string

    string - 构造函数

     简介：

    string构造函数重载的形式比较多样，最常用的是1. 默认构造函数  2. 拷贝构造函数  4. 以C字符串-const char* 为参数的构造函数。 
    其他的用的并不多。比如，string从pos位置开始的len个，C字符串的前n个，n个char，还有迭代器范围版本。

    1. void test1()
    2. {
    3.     string s0("12345abc");  // string(const char* s);
    4.     string s1;          // string();
    5.     string s2(s0);    // 拷贝构造，string(const string& s);
    6.     string s3 = s0;   // 拷贝构造，C方式的拷贝构造。
    7.     string s4 = "aaaaa";
    8. }

    分析：

    s2 为典型的拷贝构造，s3为C语言风格的拷贝构造。 值得注意的是s4，这里因为string(const char*) 版本构造函数不是explicit的，所以"aaaaa"隐式类型转换为（构造）string对象，再拷贝构造s4，编译器对此情况优化为直接进行构造。

    验证：

    当explicit string(const char* s); 时

    解除explicit后，如果在string(const char* s)构造函数和拷贝构造中加上输出语句，运行这个构造代码后，发现并没有拷贝构造的输出语句，即编译器对此优化为了直接构造。

    string - 析构函数，重载赋值运算符

    分析：

    比较简单，operator=重载了多个版本，注意区分赋值和构造的情况。析构函数在对象销毁时自动调用，用于回收清理对象申请的空间。

    模拟实现string构造，拷贝构造，重载赋值运算符，析构

    数据成员只有这几个。

    1.     private:
    2.         char* _str;
    3.         size_t _size;
    4.         size_t _capacity;
    5.     public:
    6.         const static size_t npos = -1;

    构造： 

    （都是class string的成员函数）

    1. //        string() : _size(0),_capacity(0),_str(new char[1])
    2. //        {
    3. //            _str[0] = '\0';
    4. //        }
    5.         string(const char* str = "")
    6.         {
    7.             _size = strlen(str);  // strlen不包含\0，计算的是有效字符个数。
    8.             _capacity = _size;
    9.             _str = new char[_capacity+1];
    10.  
    11.             strcpy(_str, str);  // strcpy会拷贝'\0'
    12.         }
    13.         string(size_t n, char c)
    14.         : _size(n),_capacity(n),_str(new char[n+1])
    15.         {
    16.             for(size_t i = 0; i < n; ++i)
    17.                 _str[i] = c;
    18.             _str[n] = '\0';
    19.         }

    没有全部实现，实现了几个常用的，明确size和capacity的意义，利用C语言库函数和new即可简单实现。

    拷贝构造+重载赋值运算符

    传统写法：

    1.         string(const string& s)
    2.         : _size(s._size),_capacity(s._capacity),_str(new char[s._capacity+1])
    3.         {
    4.             strcpy(_str,s._str);
    5.         }
    6. //         s1 = s3;
    7.         string& operator=(const string& s)
    8.         {
    9.             if(this != &s)
    10.             {
    11.                 delete[] this->_str;
    12.                 _str = new char[s._capacity+1];
    13.                 _size = s._size;
    14.                 _capacity = s._capacity;
    15.                 strcpy(_str,s._str);
    16.             }
    17.             return *this;
    18.         }
    19. //         略微改进了一点，考虑到如果new开空间失败，不破坏原对象。
    20.         string& operator=(const string& s)
    21.         {
    22.             if(this != &s)
    23.             {
    24.                 char* tmp = new char[s._capacity+1];
    25.                 strcpy(tmp,s._str);
    26.                 delete[] this->_str;
    27.                 _str = tmp;
    28.                 _size = s._size;
    29.                 _capacity = s._capacity;
    30.             }
    31.             return *this;
    32.         }

    现代写法：

    1.         void swap(string& tmp)
    2.         {
    3.             std::swap(_str,tmp._str);
    4.             std::swap(_size,tmp._size);
    5.             std::swap(_capacity,tmp._capacity);
    6.         }
    7.         // 现代写法： 老板思维
    8.         string(const string& s)    // string s1(s2)
    9.         :_size(0),_capacity(0),_str(nullptr)    // 如果不这样，this的_str是随机值，tmp析构时，delete[]随机值非法。
    10.         {
    11.             string tmp(s._str);   // 调用string(const char*) 构造函数
    12.             this->swap(tmp);
    13.         }
    14.         string& operator=(const string& s)
    15.         {
    16.             if (this != &s) {
    17. //                string tmp(s);
    18.                 string tmp(s._str);
    19.                 swap(tmp);
    20.             }
    21.             return *this;
    22.         }
    23.         // 最简版
    24.         string& operator=(string s)
    25.         {
    26.             swap(s);
    27.             return *this;
    28.         }
    29.  
    30.         string& operator=(const char* s) {
    31.             string tmp(s);
    32.             this->swap(tmp);
    33.             return *this;
    34.         }
    35.         ~string()
    36.         {
    37.             delete[] _str;
    38.             _str = nullptr;
    39.             _size = _capacity = 0;
    40.         }

    1. 拷贝构造的现代写法：利用string(const char* s)构造出临时对象tmp，其实就是用实参string拷贝一份，然后交换*this 和 tmp，因为这里的*this刚刚初始化完，数据成员都是随机值，如果和tmpswap之后，tmp析构时，数据成员是随机值会报错，所以利用初始化列表将*this数据成员简单初始化以下，再与tmp交换。

    2. 对于swap函数，这里利用的是string的成员函数swap，上方有实现。原因有2：a、标准库中的std::swap()对于交换的两个对象，是先拷贝构造一份，再赋值两次，对于深拷贝的自定义类型来说，效率较低。  b、std::swap()会调用交换对象的类型的拷贝构造和operator=，我们在实现的拷贝构造中使用std::swap就会造成无限递归。  所以必须使用string的成员swap，而string::swap又调用std::swap()去交换内置类型数据成员。

    3. 最简版是对上方的进一步简化，在string这里，各个版本差别不是很大，但是到了vector，list等较复杂容器时，现代写法的优势将会很明显。

    string - Element access:

    前言：

    STL中的容器，统一的访问元素方式为迭代器访问，string同样支持，但是由于string底层存储是连续的，所以operator[]  at() 会更加方便一些。

    析：

    重载了const 和 非const两个版本，配对string 和 const string，对于非const string而言，[]运算符是返回元素引用的，可读可写。类似于C语言的数组，使得访问元素更加方便。

     at于operator[]的功能一样，只是at函数在pos越界时，抛出异常，而[]运算符下标越界时直接崩溃。

    back() front() 分别返回首元素和尾元素的引用，同样重载了const和非const两个版本。略了。

    1. void test2()
    2. {
    3.     string s("1234567");
    4.     for(size_t i = 0; i < s.size(); ++i)
    5.     {
    6.         ++s[i];
    7.         ++s.at(i);
    8.         cout<
    9.         cout<at(i)<<" ";
    10.     }
    11.     cout<
    12. }

    实现：

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

    string - 迭代器iterator

    简介：

    迭代器，用于访问容器的元素，使用上类似于指针。事实上，对于string，vector这种底层存储为连续存储的容器而言，它们的迭代器就是一个改了名字的元素指针而已。而对于list map等存储不连续且复杂的容器而言，不再是普通的元素指针。

    对于string而言，使用[]访问元素会比迭代器更加方便，但是迭代器对于STL的其他容器而言至关重要，有些容器只能使用迭代器访问元素。迭代器的优点在于：通用性，简便性，对于STL所有容器来说，用法几乎一致。

    介绍：

    1. STL容器包括string，一共有四种迭代器，
    iterator   const_iterator   reverse_iterator   const_reverse_iterator   
    分别为迭代器，const迭代器，反向迭代器，const反向迭代器。

    3. begin()   end()  rbegin() rend()  cbegin()  cend()   crbegin()  crend()  分别为返回迭代器的成员函数。

    4. begin end 分别对应正向迭代器，rbegin rend对应反向迭代器

     

     上述四个成员函数，都重载了两个版本，用于const容器对象和非const容器对象，使用时自动匹配。那么，由此可见，这四个成员函数就足够得到全部种类的迭代器了，那后面四个又有什么用呢？  C++11新增了cbegin  cend  crbegin  crend，用以精确返回迭代器类型。提高代码可读性。也就可以让非const容器对象指定返回const_iterator。

    使用：

    1. 迭代器++，自动指向下一个元素，对于string，vector这种容器，迭代器++其实就是元素指针++，而对于list等底层存储不连续的容器，++为指向下一个元素，但是并不是内存中指针的++。

    1. void test3() {
    2.     string s("abcdef");
    3.     string::iterator it1 = s.begin();
    4.     while (it1 != s.end()) {
    5.         (*it1)++;
    6.         cout << *it1;
    7.         ++it1;
    8.     }
    9.     cout << endl;
    10.     string::const_reverse_iterator it2 = s.crbegin();
    11.     while (it2 != s.crend()) {
    12.         cout << *it2;
    13.         ++it2;
    14.     }
    15.     cout << endl;
    16.  
    17.     const string s1("123456");
    18.     for (string::const_iterator it = s1.begin(); it != s1.end(); ++it) {
    19.         // it为const_iterator
    20. //        (*it)++;  // error
    21.         cout << *it;
    22.     }
    23.  
    24.     for (auto i: s1) {
    25.         cout << i;
    26.     }
    27.     for (const auto &i: s1) {
    28.         cout << i;
    29.     }
    30. }

    2. 范围for的原理就是迭代器，编译器会将范围for语句自动编译为一系列关于迭代器的语句。第一个为 char i = *it   第二个为  const char& i = *it 

    7. 解引用迭代器得到元素的引用。 begin end 左闭右开。 使用迭代器时，使用it != s.end()  而不是it < s.end()  ，对于string vector，迭代器支持<运算符，但是对于list等，由于底层存储不连续，迭代器不支持<运算符。

    1. public:
    2.         typedef char* iterator;
    3.         typedef const char* const_iterator;
    4.         iterator begin()
    5.         {
    6.             return _str;
    7.         }
    8.         iterator end() {
    9.             return _str + _size;
    10.         }
    11.         const_iterator begin() const
    12.         {
    13.             return _str;
    14.         }
    15.         const_iterator end() const
    16.         {
    17.             return _str + _size;
    18.         }
    19.         const_iterator cbegin() const
    20.         {
    21.             return _str;
    22.         }
    23.         const_iterator cend() const
    24.         {
    25.             return _str+_size;
    26.         }

    简单实现，反向迭代器需要其他的学习。 

    string - 大小，容量函数

    1. size_t size() const;  返回string中有效字符个数（string底层存储时末尾有一个'\0'，与C语言一样，此'\0'不算有效字符）
    2. size_t capacity() const; 返回string可容纳字符个数，string中有些空间已经申请好了，但是没有存储字符，不算是有效字符，但是属于string的空间。

    3. void resize (size_t n); void resize (size_t n, char c);   resize用于改变string的size大小，可减小，可扩大，扩大后默认用'\0'填充。size减小后，会删除元素，但是不会改变capacity

    4. void reserve (size_t n = 0);  用于改变capacity，当n<=capacity时，无操作。当n>capacity时，会扩充容量，即申请额外的空间，但是不存储有效字符。

    5. void clear(); 用于清理string，清理后size为0 capacity不变

    6. bool empty() const;   用于判空

    7. void shrink_to_fit();   释放多余的capacity，缩减到size大小。 有时不会进行操作。

    string - 修改string操作

    0. operator+=

    1. void push_back (char c); 末尾追加一个字符

    1.5. void pop_back();   ..... 略

    2. append 在string末尾追加，重载多个版本，和构造函数的参数形式几乎一样。

    3. assign  给string重新赋值，作用等同于 operator=，和append，构造函数重载形式十分类似。

    4. insert  给某一下标位置插入某些字符，重载形式还是那一套，只是多了个pos参数，有点无趣。

    5. erase  重载三个版本，需要查询网站即可。

    6. replace  重载好多版本，其实观察一下还是那一套，pos位置len个修改为各种形式，需要时查阅

    7. void swap (string& str);  这个是string的成员函数，将调用对象和参数str交换。

    总结：append push_back 直接用+=即可，assign用operator=即可，insert erase replace 用处较小，用时查阅。

    string - 其余操作

    1.  const char* c_str() const;   返回C形式的字符串首地址。

    2.  string substr (size_t pos = 0, size_t len = npos) const;   取当前字符串的字串，从pos开始len个字符，返回一个新字符串。

    3.  各种find，用于查找子串。 莫名其妙的copy，不想弄了，心态崩了。

    完整tiny string

    1. #ifndef STL_STRING_H
    2. #define STL_STRING_H
    3.  
    4. namespace yzl
    5. {
    6.     class string
    7.     {
    8.     public:
    9.         typedef char* iterator;
    10.         typedef const char* const_iterator;
    11.         iterator begin()
    12.         {
    13.             return _str;
    14.         }
    15.         iterator end() {
    16.             return _str + _size;
    17.         }
    18.         const_iterator begin() const
    19.         {
    20.             return _str;
    21.         }
    22.         const_iterator end() const
    23.         {
    24.             return _str + _size;
    25.         }
    26.         const_iterator cbegin() const
    27.         {
    28.             return _str;
    29.         }
    30.         const_iterator cend() const
    31.         {
    32.             return _str+_size;
    33.         }
    34.     public:
    35. //        string() : _size(0),_capacity(0),_str(new char[1])
    36. //        {
    37. //            _str[0] = '\0';
    38. //        }
    39.         string(const char* str = "")
    40.         {
    41.             _size = strlen(str);  // strlen不包含\0，计算的是有效字符个数。
    42.             _capacity = _size;
    43.             _str = new char[_capacity+1];
    44.  
    45.             strcpy(_str, str);  // strcpy会拷贝'\0'
    46.         }
    47.         string(size_t n, char c)
    48.         : _size(n),_capacity(n),_str(new char[n+1])
    49.         {
    50.             for(size_t i = 0; i < n; ++i)
    51.                 _str[i] = c;
    52.             _str[n] = '\0';
    53.         }
    54.         // 传统写法
    55. //        string(const string& s)
    56. //        : _size(s._size),_capacity(s._capacity),_str(new char[s._capacity+1])
    57. //        {
    58. //            strcpy(_str,s._str);
    59. //        }
    60.         // s1 = s3;
    61. //        string& operator=(const string& s)
    62. //        {
    63. //            if(this != &s)
    64. //            {
    65. //                delete[] this->_str;
    66. //                _str = new char[s._capacity+1];
    67. //                _size = s._size;
    68. //                _capacity = s._capacity;
    69. //                strcpy(_str,s._str);
    70. //            }
    71. //            return *this;
    72. //        }
    73.         // 略微改进了一点，考虑到如果new开空间失败，不破坏原对象。
    74. //        string& operator=(const string& s)
    75. //        {
    76. //            if(this != &s)
    77. //            {
    78. //                char* tmp = new char[s._capacity+1];
    79. //                strcpy(tmp,s._str);
    80. //                delete[] this->_str;
    81. //                _str = tmp;
    82. //                _size = s._size;
    83. //                _capacity = s._capacity;
    84. //            }
    85. //            return *this;
    86. //        }
    87.  
    88.         //=======================================================
    89.         void swap(string& tmp)
    90.         {
    91.             std::swap(_str,tmp._str);
    92.             std::swap(_size,tmp._size);
    93.             std::swap(_capacity,tmp._capacity);
    94.         }
    95.         // 现代写法： 老板思维
    96.         string(const string& s)    // string s1(s2)
    97.         :_size(0),_capacity(0),_str(nullptr)    // 如果不这样，this的_str是随机值，tmp析构时，delete[]随机值非法。
    98.         {
    99.             string tmp(s._str);   // 调用string(const char*) 构造函数
    100.             this->swap(tmp);
    101.         }
    102. //        string& operator=(const string& s)
    103. //        {
    104. //            if (this != &s) {
    105.                 string tmp(s);
    106. //                string tmp(s._str);
    107. //                swap(tmp);
    108. //            }
    109. //            return *this;
    110. //        }
    111.         // 最简版
    112.         string& operator=(string s)
    113.         {
    114.             swap(s);
    115.             return *this;
    116.         }
    117.  
    118.         string& operator=(const char* s) {
    119.             string tmp(s);
    120.             this->swap(tmp);
    121.             return *this;
    122.         }
    123.  
    124.         ~string()
    125.         {
    126.             delete[] _str;
    127.             _str = nullptr;
    128.             _size = _capacity = 0;
    129.         }
    130.  
    131.         const char* c_str() const
    132.         {
    133.             return _str;
    134.         }
    135.         size_t size() const
    136.         {
    137.             return _size;
    138.         }
    139.         size_t capacity() const
    140.         {
    141.             return _capacity;
    142.         }
    143.         char& operator[](size_t pos)
    144.         {
    145.             assert(pos < _size);
    146.             return _str[pos];
    147.         }
    148.         const char& operator[](size_t pos) const
    149.         {
    150.             assert(pos<_size);
    151.             return _str[pos];
    152.         }
    153.  
    154.         void reserve(size_t n = 0)
    155.         {
    156.             if(n > _capacity)
    157.             {
    158.                 char* tmp = new char[n+1];   // n个有效数据,1用于'\0'
    159.                 strcpy(tmp,_str);
    160.                 delete[] (_str);
    161.                 _str = tmp;
    162.                 _capacity = n;    // _capacity 必须处理
    163.             }
    164.         }
    165.         void resize(size_t n, char c = '\0')
    166.         {
    167.             if(n > _size)
    168.             {
    169.                 reserve(n);
    170.                 for(size_t i = _size; i < n; ++i)
    171.                 {
    172.                     _str[i] = c;
    173.                 }
    174.                 _str[n] = '\0';
    175.                 _size = n;
    176.             }
    177.             else
    178.             {
    179.                 _str[n] = '\0';
    180.                 _size = n;
    181.             }
    182.         }
    183.         void clear()
    184.         {
    185.             _str[0] = '\0';
    186.             _size = 0;
    187.         }
    188.         bool empty() const
    189.         {
    190.             return _size == 0;
    191.         }
    192.         void push_back(char c)
    193.         {
    194.             if(_size == _capacity)
    195.             {
    196.                 reserve(_capacity == 0 ? 4 : 2*_capacity);
    197.             }
    198.             _str[_size] = c;
    199.             ++_size;
    200.             _str[_size] = '\0';
    201.         }
    202.         string& append(const char* s)
    203.         {
    204.             int size = strlen(s);
    205.             if(_size + size > _capacity)
    206.             {
    207.                 reserve(_size+size);
    208.             }
    209.             strcpy(_str+_size,s);
    210.             _size+=size;
    211.             return *this;
    212.         }
    213.         string& append(const string& s)
    214.         {
    215.             int size = s.size();
    216.             if(_size + size > _capacity)
    217.             {
    218.                 reserve(_size + size);
    219.             }
    220.             strcpy(_str+_size,s.c_str());
    221.             _size+=size;
    222.             return *this;
    223.         }
    224.         string& append(size_t n, char c)
    225.         {
    226.             if(_size + n > _capacity)
    227.             {
    228.                 reserve(_size + n);
    229.             }
    230.             for(size_t i = 0; i < n; ++i)
    231.             {
    232.                 _str[_size+i] = c;
    233.             }
    234.             _size+=n;
    235.             return *this;
    236.         }
    237. //        string& append(const string& s);   this->append(s.c_str());
    238. //        string& append(size_t n, char c);  push_back(c);
    239.         string& operator+=(char c)
    240.         {
    241.             this->push_back(c);
    242.             return *this;
    243.         }
    244.         string& operator+=(const char* s)
    245.         {
    246.             this->append(s);
    247.             return *this;
    248.         }
    249.         string& operator+=(const string& s)
    250.         {
    251.             this->append(s);
    252.             return *this;
    253.         }
    254.         string& insert(size_t pos, char c)
    255.         {
    256.             assert(pos <= _size);
    257.             if(_size == _capacity)
    258.             {
    259.                 reserve(_capacity == 0?4:2*_capacity);
    260.             }
    261. //            int end = _size;
    262. //            while(end >= (int)pos)
    263. //            {
    264. //                _str[end+1] = _str[end];
    265. //                end--;
    266. //            }
    267.             // 比较推荐的写法，主要是  int和size_t比较，会出现比较错误，当int小于0时。
    268.             size_t end = _size+1;
    269.             while(end > pos)
    270.             {
    271.                 _str[end] = _str[end-1];
    272.                 end--;
    273.             }
    274.             _str[pos] = c;
    275.             ++_size;
    276.             return *this;
    277.         }
    278.         string& insert(size_t pos, size_t n, char ch)
    279.         {
    280.             assert(pos <= _size);
    281.             // pos==0 n==0 则下面while会出错（size_t）
    282.             if(n == 0)
    283.                 return *this;
    284.             if(_size + n > _capacity)
    285.             {
    286.                 reserve(_size+n);
    287.             }
    288.             // [pos, pos+n) n个  [_size, _size+n) n个
    289.             size_t end = _size + n;
    290.             while(end >= pos+n)
    291.             {
    292.                 _str[end] = _str[end-n];
    293.                 end--;
    294.             }
    295.             for(size_t i = pos; i < pos+n; ++i)
    296.             {
    297.                 _str[i] = ch;
    298.             }
    299.             _size+=n;
    300.             return *this;
    301.         }
    302.         string& insert(size_t pos, const char* str)
    303.         {
    304.             assert(pos<=_size);
    305.             if(strlen(str) == 0)
    306.                 return *this;
    307.             int len = strlen(str);
    308.             if(_size+len > _capacity) {
    309.                 reserve(_size+len);
    310.             }
    311.             size_t end = _size+len;
    312.             while(end >= pos+len)
    313.             {
    314.                 _str[end] = _str[end-len];
    315.                 end--;
    316.             }
    317. //            int end = _size;
    318. //            while(end >= (int)pos)
    319. //            {
    320. //                _str[end+len] = _str[end];
    321. //                end--;
    322. //            }
    323.             strncpy(_str+pos,str,len);   // strcpy会把\0也copy进去。
    324.             _size+=len;
    325.             return *this;
    326.         }
    327.         string& insert(size_t n, const string& s)
    328.         {
    329.             this->insert(n,s.c_str());
    330.             return *this;
    331.         }
    332.         string& erase(size_t pos = 0, size_t len = npos)
    333.         {
    334.             assert(pos < _size);
    335.             if(len == npos || pos + len >= _size)
    336.             {
    337.                 _str[pos] = '\0';
    338.                 _size = pos;
    339.             }
    340.             else
    341.             {
    342.                 size_t i = pos + len;
    343.                 size_t p = pos;
    344.                 while(i<=_size)
    345.                 {
    346.                     _str[p] = _str[i];
    347.                     i++;
    348.                     p++;
    349.                 }
    350.                 _size -= len;
    351.             }
    352.             return *this;
    353.         }
    354.         size_t find(char c, size_t pos = 0) const
    355.         {
    356.             assert(pos < _size);
    357.             for(size_t i = pos; i < size(); ++i) {
    358.                 if(_str[i] == c)
    359.                     return i;
    360.             }
    361.             return npos;
    362.         }
    363.         size_t find(const char* str, size_t pos = 0) const
    364.         {
    365.             assert(pos < _size);
    366.             assert(str);
    367.             const char* p = strstr(_str+pos, str);
    368.             if(p == nullptr)
    369.                 return npos;
    370.             else
    371.                 return p-_str;
    372.         }
    373.         size_t find(const string& s, size_t pos = 0) const
    374.         {
    375.             return find(s.c_str(), pos);
    376.         }
    377.         string substr(size_t pos, size_t len = npos) const
    378.         {
    379.             assert(pos < _size);
    380.             if(len == npos || len + pos >= _size)
    381.             {
    382.                 len = _size - pos;
    383.             }
    384.             string ret;
    385.             for(size_t i = pos; i < pos + len; ++i)
    386.             {
    387.                 ret+=_str[pos];
    388.             }
    389.             return ret;
    390.         }
    391.         bool operator> (const string& s) const
    392.         {
    393.             return strcmp(_str, s.c_str())>0;
    394.         }
    395.         bool operator==(const string& s) const
    396.         {
    397.             return strcmp(_str, s.c_str()) == 0;
    398.         }
    399.         bool operator >=(const string& s)const
    400.         {
    401.             return *this > s || *this == s;
    402.         }
    403.         bool operator < (const string& s)const {
    404.             return !(*this >= s);
    405.         }
    406.         bool operator <= (const string& s)const {
    407.             return !(*this>s);
    408.         }
    409.         bool operator != (const string& s)const {
    410.             return !(*this == s);
    411.         }
    412.     private:
    413.         char* _str;
    414.         size_t _size;
    415.         size_t _capacity;
    416.     public:
    417.         const static size_t npos = -1;
    418. //        static size_t npos;
    419.     };
    420.  
    421.     ostream& operator<<(ostream& os, const string& s)
    422.     {
    423.         for(size_t i = 0; i < s.size(); ++i)
    424.             os<
    425.         return os;
    426.     }
    427. //    istream& operator>>(istream& is, string& s)
    428. //    {
    429. //        s.clear();
    430. //        char ch;
    431. //        ch = is.get();
    432. //        while(ch != ' ' && ch != '\n')
    433. //        {
    434. //            s += ch;
    435. //            ch = is.get();
    436. //        }
    437. //        return is;
    438. //    }
    439.     istream& operator>>(istream& is, string& s)
    440.     {
    441.         s.clear();
    442.         char ch;
    443.         ch = is.get();
    444.  
    445.         const int sz = 32;
    446.         char buff[sz];
    447.         size_t i = 0;
    448.         while(ch != ' ' && ch != '\n')
    449.         {
    450.             buff[i] = ch;
    451.             i++;
    452.             if(i == sz-1)
    453.             {
    454.                 buff[i] = '\0';
    455.                 s += buff;
    456.                 i = 0;
    457.             }
    458.             ch = is.get();
    459.         }
    460.         buff[i] = '\0';
    461.         s+=buff;
    462.         return is;
    463.     }
    464. //    size_t string::npos = -1;
    465. }
    466.  
    467.  
    468.  
    469.  
    470. #endif //STL_STRING_H

  • 相关阅读:
    2021全国大学生电子设计竞赛论文（智能送药小车（F题））（电赛论文模板）
    微服务开发与实战Day01 - MyBatisPlus
    资料库的webrtc文件传输
    【代码随想录】栈与队列专栏（java版本）
    10个必备的 async/await 工具函数
    引用Geoip实现由IP地址获取国家城市等信息
    vue模板语法上集
    Java 使用 poi 和 aspose 实现 word 模板数据写入并转换 pdf 增加水印
    强化学习问题（一）--- 输入conda activate base无法激活虚拟环境
    [C/C++] 数据结构 链表OJ题:相交链表(寻找两个链表的相交起始结点)
  • 原文地址：https://blog.csdn.net/i777777777777777/article/details/126435973