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

                                                         🎬慕斯主页：修仙—别有洞天

                                                           ♈️今日夜电波：缶ビール—みゆな

                                                                    0:41━━━━━━️💟──────── 2:52
                                                                        🔄   ◀️   ⏸   ▶️    ☰ 

                                          💗关注👍点赞🙌收藏您的每一次鼓励都是对我莫大的支持😍

    目录

    一、string实际的底层原理

    二、string的模拟实现

            基本成员函数 

            构造函数 

            拷贝构造函数

            析构函数

            重载赋值运算符 

            迭代器

            迭代器的概念 

            begin（）

            end（）

            空间管理

            修改相关

            push_back（）

            append （）​编辑

            重载+=运算符

            c_str （）

            clear（）

            swap（）

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

             关系运算符的重载

             基本操作

            查找find（） 

            前置知识substr（）

            插入insert（）

            删除 erase（）

            流插入流提取

     总体代码

    一、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. };

    二、string的模拟实现

            基本成员函数 

            构造函数 

            通过设置缺省参数以及初始化列表来默认构造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.         }

            在模拟实现string的构造函数时，很多人包括作者我一开始都会想着将他分为有参以及无参两部分，但是这种做法是会产生一定的问题的，如下为作者写出的错误的代码：

    1. class string
    2.     {
    3.  
    4.     public:
    5.         string()//无参构造函数
    6.             //初始化列表
    7.             :_str(nullptr)
    8.             , _size(0)
    9.             , _capacity(0)
    10.         {
    11.  
    12.         }
    13.         string(char* str)//带参构造函数->char a[] = "abc";string kk(a)
    14.             :_str(str),
    15.             _size(strlen(str)),
    16.             _capacity(strlen(str))
    17.         {
    18.  
    19.         }
    20.  
    21.         string(const char* str)//带参构造函数->string kk("abc")
    22.             :_str(str),
    23.             _size(strlen(str)),
    24.             _capacity(strlen(str))
    25.         {
    26.  
    27.         }
    28.     private:
    29.  
    30.         char* _str;
    31.  
    32.         size_t _capacity;
    33.  
    34.         size_t _size;
    35.  
    36.     };

            对于以上代码，若调用如上的带参构造函数中string(const char* str)就会报错，因为str传给_str属于权限放大，现在有两种解决方法，一种是将它改为 string(char* str)，但是这样就不能直接传递字符串，需要先生成字符串，还有一种方法是将_str改为const char*类型，但是此时就不能修改_str指向的内容，后续的一些操作会出现一些错误。

             拷贝构造函数

            由于我们使用了开辟了空间来用于储存数据，因此我们需要进行深拷贝，防止对于另外一个对象的影响。

            传统写法： 

            开辟对应的空间，然后再给相应的值。

    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. void swap(string& s)
    2.         {
    3.             std::swap(_str, s._str);
    4.             std::swap(_size, s._size);
    5.             std::swap(_capacity, s._capacity);
    6.         }
    7.  
    8.         string(const string& s)
    9.             :_str(nullptr)
    10.             ,_size(0)
    11.             ,_capacity(0)
    12.         {
    13.             string tmp(s._str);
    14.             swap(tmp);
    15.         }

            析构函数

            避免内存泄漏需要自己写一个析构函数用以销毁new在堆区所创建的空间 

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

            重载赋值运算符 

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

            传统写法： 

            开辟对应的空间，然后再给相应的值。

    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);
    7.  
    8.         //		delete[] _str;
    9.         //		_str = tmp;
    10.         //		_size = s._size;
    11.         //		_capacity = s._capacity;
    12.         //	}
    13.  
    14.         //	return *this;
    15.         //}

            较为推荐的写法：

            通过让构造函数帮我们创建一个构造相应的字符的对象，然后我们再交换两个对象的数据即可得。

    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.         	}
    10.  
    11.         	return *this;
    12.         }

            再简化一点：通过在传值时进行拷贝构造，然后交换数据。

    1. string& operator=(string tmp)
    2.         {
    3.             swap(tmp);
    4.  
    5.             return *this;
    6.         }

             迭代器

            迭代器的概念 

             C++迭代器是一种用于遍历容器中元素的对象，它提供了一种统一的接口，使得不同类型的容器都可以使用相同的方式进行遍历。迭代器可以指向容器中的某个元素，并用于访问该元素的值或者进行修改。迭代器通常是一个类，它重载了指针操作符（*和->），以及自增（++）和自减（--）运算符，使得迭代器可以像指针一样进行移动。

            string的迭代器实际实现原理：

            string的迭代器实际上是一个指向string底层存储空间中char类型数据的指针，不同的迭代器类型标志着不同的访问权限。例如，一个string::iterator对象可以用来读写字符，而一个const string::iterator对象只能用来读取字符。

            于是我们定义出以下的迭代器：

    1.         typedef char* iterator;
    2.         typedef const char* const_iterator;

             begin（）

            用于返回第一个字符的地址。

    1.         iterator begin()
    2.         {
    3.             return _str; 
    4.         }
    5.         const_iterator begin()const
    6.         {
    7.             return _str; 
    8.         }

          end（）

            用于返回后一个字符的后一个字符的地址的地址。其实就是‘\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.         }
    5.  
    6.         size_t capacity()const//空间
    7.         {
    8.             return _capacity;
    9.         }
    10.  
    11.         bool empty()const//空？
    12.         {
    13.             return _size == 0;
    14.         }
    15.  
    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;
    23.  
    24.                 _str = tmp;
    25.                 _capacity = n;
    26.             }
    27.         }
    28.  
    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.                 }
    44.  
    45.                 _str[_size] = '\0';
    46.             }
    47.         }
    48.

             修改相关

             push_back（）

             根据原型可知此函数是在当前字符串尾插一个字符，其中需要额外注意容量。

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

            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.  
    9.             strcpy(_str + _size, str);//拷贝到原字符串后
    10.             _size += len;
    11.         }

             重载+=运算符

             此处复用了以上的push_back和append函数，这也是根据C++中函数管用的复用习惯来做出的选择。

    1.  string& operator+=(char c)
    2.         {
    3.             push_back(c);
    4.         }
    5.  
    6.         string& operator+=(const char* str)
    7.         {
    8.             append(str);
    9.  
    10.             return *this;
    11.         }

            c_str （）

            返回指向数组的指针，该数组包含以 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.         char& operator[](size_t index)
    2.         {
    3.             assert(index < _size);
    4.  
    5.             return _str[index];
    6.         }
    7.  
    8.         const char& operator[](size_t index)const
    9.         {
    10.             assert(index < _size);
    11.  
    12.             return _str[index];
    13.         }

             关系运算符的重载

            关系运算符的重载的关键就是根据所需进行相应的数据变化以及做出值的返回。 

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

             基本操作

            查找find（） 

            由原型知，分为按照字符查找以及字符串查找还有常量字符串查找，对此，此次实现字符以及字符串查找。

            对于字符查找： 

    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.             }
    10.  
    11.             return npos;
    12.         }

            对于字符串查找： 

            前置知识substr（）

             他的主要作用就是在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.             }
    10.  
    11.             s.reserve(len);
    12.             for (size_t i = pos; i < end; i++)
    13.             {
    14.                 s += _str[i];
    15.             }
    16.  
    17.             return s;
    18.         }
    19.  
    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.  
    3.         void insert(size_t pos, char ch)
    4.         {
    5.             assert(pos <= _size);
    6.             if (_size == _capacity)
    7.             {
    8.                 reserve(_capacity == 0 ? 4 : _capacity * 2);
    9.             }
    10.  
    11.             size_t end = _size + 1;
    12.             while (end > pos)
    13.             {
    14.                 _str[end] = _str[end - 1];
    15.                 --end;
    16.             }
    17.  
    18.             _str[pos] = ch;
    19.             _size++;
    20.         }
    21.  
    22.         void insert(size_t pos, const char* str)
    23.         {
    24.             assert(pos <= _size);
    25.  
    26.             size_t len = strlen(str);
    27.             if (_size + len > _capacity)
    28.             {
    29.                 reserve(_size + len);
    30.             }
    31.  
    32.             // 挪动数据
    33.             int end = _size;
    34.             while (end >= (int)pos)
    35.             {
    36.                 _str[end + len] = _str[end];
    37.                 --end;
    38.             }
    39.  
    40.             strncpy(_str + pos, str, len);
    41.             _size += len;
    42.         }

            删除 erase（）

             删除指定位置的字符，可根据调节删除的数量，默认是指定位置以后全删。

    1.         void erase(size_t pos, size_t len = npos)
    2.         {
    3.             assert(pos < _size);
    4.  
    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. 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;
    9.  
    10.     return out;
    11. }
    12.  
    13. istream& operator>>(istream& in, string& s)
    14. {
    15.  
    16.     s.clear();
    17.  
    18.     char buff[129];
    19.     size_t i = 0;
    20.  
    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.         }
    32.  
    33.         //s += ch;
    34.  
    35.         ch = in.get();
    36.     }
    37.  
    38.     if (i != 0)
    39.     {
    40.         buff[i] = '\0';
    41.         s += buff;
    42.     }
    43.  
    44.     return in;
    45. }

     总体代码

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

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

                                           

                                                                             给个三连再走嘛~  

  • 相关阅读:
    从“pmp::indextype“转换到“const storageindex &“需要收缩转换
    Flask 学习-13.Flask-SQLAlchemy 新建模型和字段
    Paddle Graph Learning (PGL)图学习之图游走类模型[系列四]
    【DevOps系列】Docker数据卷（volume）详解
    电商API接口汇总，引领企业国际化
    【原创】基于SSM的体育场地预约管理系统（毕业设计源码）
    Docker快速入门到项目部署，docker自定义镜像
    MySQL - 普通索引
    【LeetCode刷题（数据结构与算法）】：将二叉搜索树转化为排序的双向链表
    BI系统的分布式部署原理和技术实现
  • 原文地址：https://blog.csdn.net/weixin_64038246/article/details/134422860