devbox
很楠不爱3
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

C++ stl容器string的底层模拟实现

作者：很楠不爱3 | 2024-06-11 23:51:17

赞

踩

C++ stl容器string的底层模拟实现

目录

前言：

1.成员变量

2.构造函数与拷贝构造函数

3.析构函数

4.赋值重载

5.[]重载

6.比较关系重载

7.reserve

8.resize

9.push_back,append和重载+=

10.insert

11.erase

12.find

14.迭代器

15.流插入，流提取重载

16.swap

17.c_str

18.完整代码+测试

总结：

前言：
本篇模拟string类的底层实现，只会调一些重要的接口实现，结尾附上完整代码。

1.成员变量

  1. 	private:
  2. 		//const char* _str
  3. 		//不使用const修饰，string类的字符串是可以修改的，而且例如扩容的时候也需要修改指针的指向
  4. 		// 然后就是_str的初始化是最好new出来的，如果直接初始化为空指针，例如在流插入的时候需要解引用，就不行了。		
  5. 		char* _str;
  6. 		size_t _capacity;
  7. 		size_t _size;
  8.  
  9. 		//static const size_t npos=-1;//静态成员变量要在类外声明初始化，不能给缺省值，但是如果加上const，又支持这样给缺省值的语法了
  10. 		static const size_t npos;

首先注意的就是_str，不能是const类型的，因为我们的string字符串是可以改的，而且如果是const类型的，在扩容等也需要改变指针的指向；而且我们在流插入的时候解引用，所以在初始化的时候最好是new出来的。

静态成员常量npos需要在类外声明初始化，注意的是，本来静态成员变量是不能给缺省值的，但是加上了const就又可以给缺省值了。

2.构造函数与拷贝构造函数

  1. 		string(const char* str="")//strlen遇到字符0就停了，这样传参数也正好，无参的size也是0，或者写成"\0",但是不能写成'\0'类型不匹配
  2. 			:_size(strlen(str))//strlen内部获取字符串长度是需要解引用的，所以最好初始化不要给空指针，
  3. 		{
  4. 			_capacity = _size == 0 ? 3 : _size;
  5. 			_str = new char[_capacity + 1];//+1给字符0准备，实际capacity没有字符0
  6. 			strcpy(_str, str);
  7. 		}
  8.  
  9. 	    string(const string& st)
  10. 			:_size(st._size)
  11. 			,_capacity(st._capacity)
  12. 		{
  13. 			_str = new char[st._capacity + 1];//+1给字符0准备，实际capacity没有字符0
  14. 			strcpy(_str, st._str);
  15. 		}

构造的参数这样写是因为这样传参数相当于无参的构造只有一个字符0，正好符合strlen计算长度的规则，无参的时候_size就是0了。

_capacity需要判断是否为0，不然什么都没有直接二倍扩容会出错。

_str的容量加1是给字符0准备的，但是实际_size与_capacity是没有计算字符0的，而且在调试的时候也看不到，但是还是要加上。

构造的思路就是根据传参字符串的的容量开一块新的空间，进行拷贝完成初始化。

拷贝构造就是深拷贝了，所以就是根据要拷贝的对象的大小开一块空间，再让空间拷贝给给调用的对象，注意容量与大小也要变。

3.析构函数

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

注意配套使用delete就行。

4.赋值重载

  1. 		string& operator=(const string& st)
  2. 		{
  3. 			//这样写如果new出错了，原来的对象也被破坏了
  4. 			//delete[] _str;
  5. 			//_str = new char[st._capacity + 1];
  6. 			//strcpy(_str, st._str);
  7. 			//_capacity = st._capacity;
  8. 			//_size = st._size;
  9.  
  10.  
  11. 			if (this != &st)
  12. 			{
  13. 				char* tmp = new char[st._capacity + 1];
  14. 				strcpy(tmp,st._str);
  15. 				delete[] _str;
  16. 				_str = tmp;
  17.  
  18. 				_capacity = st._capacity;
  19. 				_size = st._size;
  20.  
  21. 				return *this;
  22. 			}
  23. 		}

赋值重载就要考虑空间的问题了，同时也是一个深拷贝。

假设s1=s2，如果s1容量多，直接将s2赋值过去没问题，但是会造成空间的浪费。

如果s1的空间少，此时再将s2赋值就会出现问题了，所以综合一下：先让原空间也就是被赋值的空间给释放掉，然后再根据赋值的内容开辟空间，让被赋值的指向这块新的空间，再进行拷贝，并完成大小和容量的更新。

上面的为注释的写法，但是还有一点问题，如果new失败了，那被赋值的空间早已被释放了，这就破坏了原来的空间，所以为了不破坏原有的空间，先根据赋值的内容开一块空间，再将赋值的内容拷贝给这块空间，此时再释放旧空间，再将旧空间指向新空间即可。

注意要判断自己不能给自己赋值。

5.[]重载

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

注意断言，下标位置不能等于_size，_size指向最后一个字符的下一个也就是字符0，但是实际库中的string的字符0我们是可以访问到的，这里主要表示有效数据的访问。

要提供两个版本，方便const对象调用。 

6.比较关系重载

  1. 		 //string比较
  2. 		 bool operator>(const string& st) const
  3. 		 {
  4. 			 return strcmp(_str, st._str) > 0;
  5. 		 }
  6.  
  7. 		 bool operator==(const string& st) const
  8. 		 {
  9. 			 return strcmp(_str, st._str) == 0;
  10. 		 }
  11. 		 
  12. 		 bool operator>=(const string& st) const
  13. 		 {
  14. 			 return *this > st || *this == st;//如果不用const修饰==的重载，这里调用就不能st==*this了，因为st是const类型的		 
  15. 		 }
  16.  
  17. 		 bool operator<(const string& st) const
  18. 		 {
  19. 			 return !(*this >= st);
  20. 		 }
  21.  
  22. 		 bool operator<=(const string& st) const
  23. 		 {
  24. 			 return !(*this > st);
  25. 		 }
  26.  
  27. 		 bool operator!=(const string& st) const
  28. 		 {
  29. 			 return !(*this == st);
  30. 		 }

这个没什么好说的了，就是写两个复用就完了。

注意没有修改成员变量的成员函数最好还是就是const，像>=复用==的逻辑的时候，如果==不是const的成员函数，就不能倒过来写了。 

7.reserve

  1. 		 void reserve(size_t n)
  2. 		 {
  3. 			 if (n > _capacity)//如果n小于这块空间，相当于缩容了，原字符串再拷贝给缩容的空间就越界了
  4. 			 {
  5. 				 char* tmp = new char[n + 1];//这里一样是放在原对象被破坏，+1用来存放字符0
  6. 				 strcpy(tmp, _str);
  7. 				 delete[] _str;
  8. 				 _str = tmp;
  9.  
  10. 				 _capacity = n;//但是capacity实际还是没有字符0的
  11. 			 }

注意判断扩容的大小不能小于原有的容量，不然就是缩容了，缩容再拷贝数据就越界了。

8.resize

  1. 		 void resize(size_t n, char ch = '\0')
  2. 		 {
  3. 			 if (n <= _capacity)
  4. 			 {
  5. 				 //保留前n个数据
  6. 				 _size = n;
  7. 				 _str[_size] = '\0';
  8. 			 }
  9. 			 else
  10. 			 {
  11. 				 if (n > _capacity)
  12. 				 {
  13. 					 reserve(n);
  14. 				 }
  15.  
  16. 				 size_t i = _size;//直接在后面补初始化的数据
  17. 				 while (i < n)
  18. 				 {
  19. 					 _str[i] = ch;
  20. 					 ++i;
  21. 				 }
  22.  
  23. 				 _size = n;
  24. 				 _str[_size] = '\0';
  25. 			 }
  26. 		 }

如果扩容大小小于容量，那就保留前n个数据，末尾改成字符0。

如果大，那就扩容，原有数据不变，扩容后面的数据都默认初始化为字符0。如果传的有参数，就往末尾补数据，最后别忘了更新size，还要在最后补字符0。

9.push_back,append和重载+=

  1. 		 void push_back(char ch)
  2. 		 {
  3. 			 if (_size + 1 > _capacity)
  4. 			 {
  5. 				 reserve(_capacity * 2);
  6. 			 }
  7.  
  8. 			 _str[_size] = ch;
  9. 			 ++_size;
  10. 			 _str[_size] = '\0';//插入完了，字符串后面的字符0就找不到了，所以size更新完后再补一个字符0
  11.  
  12. 			 //复用insert
  13. 			 //insert(_size,ch)
  14. 		 }
  15.  
  16. 		 void append(const char* str)
  17. 		 {
  18. 			 size_t len = strlen(str);
  19. 			 if (_size + len > _capacity)
  20. 			 {
  21. 				 reserve(_size + len);
  22. 			 }
  23.  
  24. 			 strcpy(_str + _size, str);//正好覆盖了原字符串的字符0
  25. 			 _size += len;
  26.  
  27. 			 //复用insert
  28. 			 //insert(_size,str)
  29. 		 }
  30. 		 string& operator+=(char ch)
  31. 		 {
  32. 			 push_back(ch);
  33. 			 return *this;
  34. 		 }
  35.  
  36. 		 string& operator+=(const char* str)
  37. 		 {
  38. 			 append(str);
  39. 			 return *this;
  40. 		 }
  41.

注意尾插一个字符时的字符0的补充以及扩容即可。 

10.insert

  1. 		 string& insert(size_t pos, char ch)
  2. 		 {
  3. 			 assert(pos <= _size);
  4. 			 if (_size + 1 > _capacity)
  5. 			 {
  6. 				 reserve(_capacity * 2);
  7. 			 }
  8. 			 size_t end = _size + 1;
  9.  
  10. 			 while (end > pos)
  11. 			 {
  12. 				 _str[end] = _str[end - 1];
  13. 				 --end;
  14. 			 }
  15.  
  16. 			 _str[pos] = ch;
  17. 			 ++_size;
  18.  
  19. 			 return *this;
  20. 		 }
  21.  
  22. 		 string& insert(size_t pos, const char* str)
  23. 		 {
  24. 			 assert(pos <= _size);
  25. 			 size_t len = strlen(str);
  26. 			 if (_size + len > _capacity)
  27. 			 {
  28. 				 reserve(_size + len);
  29. 			 }
  30.  
  31. 			 size_t end = _size + len;
  32. 			 while (end >pos+len-1)
  33. 			 {
  34. 				 _str[end] = _str[end - len];
  35. 				 --end;
  36. 			 }
  37. 			 strncpy(_str + pos, str, len);
  38. 			 _size += len;
  39. 			 return *this;
  40.  
  41. 		 }

这个建议画图理解，也一样先扩容。

注意断言，在等于size的时候插入就是尾插入，不用添加字符0，直接交换了，注意pos是下标。 

11.erase

  1. 		 string& erase(size_t pos, size_t len = npos)//删除pos位置（包括pos位置）后的len个字符，如果不够删，就删完
  2. 		 {
  3. 			 assert(pos < _size);
  4. 			 if (len == npos || pos + len >= _size)
  5. 			 {
  6. 				 _str[pos] = '\0';//pos也被删了
  7. 				 _size = pos;
  8. 			 }
  9. 			 else
  10. 			 {
  11. 				 strcpy(_str + pos, _str + pos + len);
  12. 				 _size -= len;
  13. 			 }
  14.  
  15. 			 return *this;
  16. 		 }

当等于缺省值的时候或者要删的字符正好删到了最后一个有效数据，直接就是在pos的位置放字符0，更新size就行了（注意pos位置的值也被删了）。

如果没有删完，就将删除后右边的子串与原字符串连接起来，更新size。 

12.find

  1. 		 size_t find(char ch, size_t pos=0)//pos为0就是代表找这个字符出现的第一个位置，返回下标；为1就是返回出现第二次的位置的下标
  2. 		 {
  3. 			 assert(pos < _size);
  4. 			 for (size_t i = pos; i < _size; ++i)
  5. 			 {
  6. 				 if (_str[i] == ch)
  7. 				 {
  8. 					 return i;
  9. 				 }
  10. 			 }
  11.  
  12. 			 return npos;
  13. 		 }
  14.  
  15. 		 size_t find(const char* str, size_t pos = 0)
  16. 		 {
  17. 			 char* p = strstr(_str + pos, str);//找子串可以使用暴力的kmp，但是实际作用不大，还有BM算法；strstr使用的是暴力的算法
  18. 			 if (p == nullptr)
  19. 			 {
  20. 				 return npos;
  21. 			 }
  22. 			 else
  23. 			 {
  24. 				 return p - _str;
  25. 			 }
  26. 		 }

 查找字符就是遍历一遍就行了，查找字符串需要使用strstr或者算法，也就是查找子串，strstr返回的是子串的首元素位置。

14.迭代器

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

对指针的重命名，后面容器的实现更复杂，后面再说。

注意还有const迭代器，供const对象调用，这里分开划分const成员与非const成员函数主要是因为我们使用普通迭代器大部分会修改数据。 

15.流插入，流提取重载

  1. 	ostream& operator<<(ostream& out, const string& s)
  2. 	{
  3. 		for (auto ch : s)
  4. 		{
  5. 			out << ch;//有些编译器会让字符0打印成空格
  6. 		}
  7.  
  8. 		return out;
  9. 	}
  10.  
  11. 	istream& operator>>(istream& in, string& s)
  12. 	{
  13. 		s.clear();
  14. 		char ch = in.get();
  15. 		char buff[128];
  16. 		size_t i = 0;
  17. 		while (ch != ' ' && ch != '\n')
  18. 		{
  19. 			buff[i++] = ch;
  20. 			if (i == 127)
  21. 			{
  22. 				buff[127] = '\0';
  23. 				s += buff;
  24. 				i = 0;
  25. 			}
  26.  
  27. 			ch = in.get();
  28. 		}
  29.  
  30. 		if (i != 0)//防止后面还有数据没填
  31. 		{
  32. 			buff[i] = '\0';
  33. 			s += buff;
  34. 		}
  35.  
  36. 		return in;
  37. 	}

注意不是友元，没有访问类的成员。 

16.swap

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

直接复用即可，如果直接写调用要写成s1.swap(s2)，会有两个对象三个深拷贝。 

17.c_str

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

直接返回首字符地址，注意是const类型的。 

18.完整代码+测试

  1. #pragma once
  2. #include <string>
  3. #include <string.h>
  4. #include <assert.h>
  5. #include <iostream>
  6.  
  7. using namespace std;
  8.  
  9. namespace my_string
  10. {
  11. 	class string
  12. 	{
  13. 	public:
  14. 		typedef char* iterator;
  15. 		typedef const char* const_iterator;
  16.  
  17. 		iterator begin()
  18. 		{
  19. 			return _str;
  20. 		}
  21.  
  22. 		iterator end()
  23. 		{
  24. 			return _str + _size;
  25. 		}
  26.  
  27. 		const_iterator begin() const
  28. 		{
  29. 			return _str;
  30. 		}
  31.  
  32. 		const_iterator end() const
  33. 		{
  34. 			return _str + _size;
  35. 		}
  36.  
  37. 		string(const char* str="")//strlen遇到字符0就停了，这样传参数也正好，无参的size也是0，或者写成"\0",但是不能写成'\0'类型不匹配
  38. 			:_size(strlen(str))//strlen内部获取字符串长度是需要解引用的，所以最好初始化不要给空指针，
  39. 		{
  40. 			_capacity = _size == 0 ? 3 : _size;
  41. 			_str = new char[_capacity + 1];//+1给字符0准备，实际capacity没有字符0
  42. 			strcpy(_str, str);
  43. 		}
  44.  
  45. 	    string(const string& st)
  46. 			:_size(st._size)
  47. 			,_capacity(st._capacity)
  48. 		{
  49. 			_str = new char[st._capacity + 1];//+1给字符0准备，实际capacity没有字符0
  50. 			strcpy(_str, st._str);
  51. 		}
  52.  
  53. 		string& operator=(const string& st)
  54. 		{
  55. 			//这样写如果new出错了，原来的对象也被破坏了
  56. 			//delete[] _str;
  57. 			//_str = new char[st._capacity + 1];
  58. 			//strcpy(_str, st._str);
  59. 			//_capacity = st._capacity;
  60. 			//_size = st._size;
  61.  
  62.  
  63. 			if (this != &st)
  64. 			{
  65. 				char* tmp = new char[st._capacity + 1];
  66. 				strcpy(tmp,st._str);
  67. 				delete[] _str;
  68. 				_str = tmp;
  69.  
  70. 				_capacity = st._capacity;
  71. 				_size = st._size;
  72.  
  73. 				return *this;
  74. 			}
  75. 		}
  76.  
  77. 		~string()
  78. 		{
  79. 			delete[] _str;
  80. 			_str = nullptr;
  81. 			_size = 0;
  82. 			_capacity = 0;
  83. 		}
  84.  
  85. 		const char* c_str()
  86. 		{
  87. 			return _str;
  88. 		}
  89.  
  90. 		const char& operator[](size_t pos) const
  91. 		{
  92. 			assert(pos < _size);
  93. 			return _str[pos];
  94. 		}
  95.  
  96. 		char& operator[](size_t pos) 
  97. 		{
  98. 			assert(pos < _size);
  99. 			return _str[pos];
  100. 		}
  101.  
  102. 		 size_t size() const//size和capacity实际都没有算字符0，但是在string里面实际是有这个字符0的,但是调试是看不到的
  103. 		 {
  104. 			 return _size;
  105. 		 }
  106.  
  107. 		 size_t capacity() const
  108. 		 {
  109. 			 return _capacity;
  110. 		 }
  111.  
  112. 		 //string比较
  113. 		 bool operator>(const string& st) const
  114. 		 {
  115. 			 return strcmp(_str, st._str) > 0;
  116. 		 }
  117.  
  118. 		 bool operator==(const string& st) const
  119. 		 {
  120. 			 return strcmp(_str, st._str) == 0;
  121. 		 }
  122. 		 
  123. 		 bool operator>=(const string& st) const
  124. 		 {
  125. 			 return *this > st || *this == st;//如果不用const修饰==的重载，这里调用就不能st==*this了，因为st是const类型的		 
  126. 		 }
  127.  
  128. 		 bool operator<(const string& st) const
  129. 		 {
  130. 			 return !(*this >= st);
  131. 		 }
  132.  
  133. 		 bool operator<=(const string& st) const
  134. 		 {
  135. 			 return !(*this > st);
  136. 		 }
  137.  
  138. 		 bool operator!=(const string& st) const
  139. 		 {
  140. 			 return !(*this == st);
  141. 		 }
  142.  
  143. 		 void reserve(size_t n)
  144. 		 {
  145. 			 if (n > _capacity)//如果n小于这块空间，相当于缩容了，原字符串再拷贝给缩容的空间就越界了
  146. 			 {
  147. 				 char* tmp = new char[n + 1];//这里一样是放在原对象被破坏，+1用来存放字符0
  148. 				 strcpy(tmp, _str);
  149. 				 delete[] _str;
  150. 				 _str = tmp;
  151.  
  152. 				 _capacity = n;//但是capacity实际还是没有字符0的
  153. 			 }
  154. 		 }
  155.  
  156. 		 void push_back(char ch)
  157. 		 {
  158. 			 if (_size + 1 > _capacity)
  159. 			 {
  160. 				 reserve(_capacity * 2);
  161. 			 }
  162.  
  163. 			 _str[_size] = ch;
  164. 			 ++_size;
  165. 			 _str[_size] = '\0';//插入完了，字符串后面的字符0就找不到了，所以size更新完后再补一个字符0
  166.  
  167. 			 //复用insert
  168. 			 //insert(_size,ch)
  169. 		 }
  170.  
  171. 		 void append(const char* str)
  172. 		 {
  173. 			 size_t len = strlen(str);
  174. 			 if (_size + len > _capacity)
  175. 			 {
  176. 				 reserve(_size + len);
  177. 			 }
  178.  
  179. 			 strcpy(_str + _size, str);//正好覆盖了原字符串的字符0
  180. 			 _size += len;
  181.  
  182. 			 //复用insert
  183. 			 //insert(_size,str)
  184. 		 }
  185.  
  186. 		 string& operator+=(char ch)
  187. 		 {
  188. 			 push_back(ch);
  189. 			 return *this;
  190. 		 }
  191.  
  192. 		 string& operator+=(const char* str)
  193. 		 {
  194. 			 append(str);
  195. 			 return *this;
  196. 		 }
  197.  
  198. 		 void resize(size_t n, char ch = '\0')
  199. 		 {
  200. 			 if (n <= _capacity)
  201. 			 {
  202. 				 //保留前n个数据
  203. 				 _size = n;
  204. 				 _str[_size] = '\0';
  205. 			 }
  206. 			 else
  207. 			 {
  208. 				 if (n > _capacity)
  209. 				 {
  210. 					 reserve(n);
  211. 				 }
  212.  
  213. 				 size_t i = _size;//直接在后面补初始化的数据
  214. 				 while (i < n)
  215. 				 {
  216. 					 _str[i] = ch;
  217. 					 ++i;
  218. 				 }
  219.  
  220. 				 _size = n;
  221. 				 _str[_size] = '\0';
  222. 			 }
  223. 		 }
  224.  
  225. 		 string& insert(size_t pos, char ch)
  226. 		 {
  227. 			 assert(pos <= _size);
  228. 			 if (_size + 1 > _capacity)
  229. 			 {
  230. 				 reserve(_capacity * 2);
  231. 			 }
  232. 			 size_t end = _size + 1;
  233.  
  234. 			 while (end > pos)
  235. 			 {
  236. 				 _str[end] = _str[end - 1];
  237. 				 --end;
  238. 			 }
  239.  
  240. 			 _str[pos] = ch;
  241. 			 ++_size;
  242.  
  243. 			 return *this;
  244. 		 }
  245.  
  246. 		 string& insert(size_t pos, const char* str)
  247. 		 {
  248. 			 assert(pos <= _size);
  249. 			 size_t len = strlen(str);
  250. 			 if (_size + len > _capacity)
  251. 			 {
  252. 				 reserve(_size + len);
  253. 			 }
  254.  
  255. 			 size_t end = _size + len;
  256. 			 while (end >pos+len-1)
  257. 			 {
  258. 				 _str[end] = _str[end - len];
  259. 				 --end;
  260. 			 }
  261. 			 strncpy(_str + pos, str, len);
  262. 			 _size += len;
  263. 			 return *this;
  264.  
  265. 		 }
  266.  
  267. 		 string& erase(size_t pos, size_t len = npos)//删除pos位置（包括pos位置）后的len个字符，如果不够删，就删完
  268. 		 {
  269. 			 assert(pos < _size);
  270. 			 if (len == npos || pos + len >= _size)
  271. 			 {
  272. 				 _str[pos] = '\0';//pos也被删了
  273. 				 _size = pos;
  274. 			 }
  275. 			 else
  276. 			 {
  277. 				 strcpy(_str + pos, _str + pos + len);
  278. 				 _size -= len;
  279. 			 }
  280.  
  281. 			 return *this;
  282. 		 }
  283.  
  284. 		 void swap(string& st)
  285. 		 {
  286. 			 std::swap(_str, st._str);
  287. 			 std::swap(_size, st._size);
  288. 			 std::swap(_capacity, st._capacity);
  289. 		 }
  290.  
  291. 		 size_t find(char ch, size_t pos=0)//pos为0就是代表找这个字符出现的第一个位置，返回下标；为1就是返回出现第二次的位置的下标
  292. 		 {
  293. 			 assert(pos < _size);
  294. 			 for (size_t i = pos; i < _size; ++i)
  295. 			 {
  296. 				 if (_str[i] == ch)
  297. 				 {
  298. 					 return i;
  299. 				 }
  300. 			 }
  301.  
  302. 			 return npos;
  303. 		 }
  304.  
  305. 		 size_t find(const char* str, size_t pos = 0)
  306. 		 {
  307. 			 char* p = strstr(_str + pos, str);//找子串可以使用暴力的kmp，但是实际作用不大，还有BM算法；strstr使用的是暴力的算法
  308. 			 if (p == nullptr)
  309. 			 {
  310. 				 return npos;
  311. 			 }
  312. 			 else
  313. 			 {
  314. 				 return p - _str;
  315. 			 }
  316. 		 }
  317. 		 
  318. 		 void clear()
  319. 		 {
  320. 			 _str[0] = '\0';
  321. 			 _size = 0;
  322. 		 }
  323. 	private:
  324. 		//const char* _str
  325. 		//不使用const修饰，string类的字符串是可以修改的，而且例如扩容的时候也需要修改指针的指向
  326. 		// 然后就是_str的初始化是最好new出来的，如果直接初始化为空指针，例如在流插入的时候需要解引用，就不行了。		
  327. 		char* _str;
  328. 		size_t _capacity;
  329. 		size_t _size;
  330.  
  331. 		//static const size_t npos=-1;//静态成员变量要在类外声明初始化，不能给缺省值，但是如果加上const，又支持这样给缺省值的语法了
  332. 		static const size_t npos;
  333.  
  334. 	};
  335.  
  336. 	const size_t string::npos = -1;
  337.  
  338. 	ostream& operator<<(ostream& out, const string& s)
  339. 	{
  340. 		for (auto ch : s)
  341. 		{
  342. 			out << ch;//有些编译器会让字符0打印成空格
  343. 		}
  344.  
  345. 		return out;
  346. 	}
  347.  
  348. 	istream& operator>>(istream& in, string& s)
  349. 	{
  350. 		s.clear();
  351. 		char ch = in.get();
  352. 		char buff[128];
  353. 		size_t i = 0;
  354. 		while (ch != ' ' && ch != '\n')
  355. 		{
  356. 			buff[i++] = ch;
  357. 			if (i == 127)
  358. 			{
  359. 				buff[127] = '\0';
  360. 				s += buff;
  361. 				i = 0;
  362. 			}
  363.  
  364. 			ch = in.get();
  365. 		}
  366.  
  367. 		if (i != 0)//防止后面还有数据没填
  368. 		{
  369. 			buff[i] = '\0';
  370. 			s += buff;
  371. 		}
  372.  
  373. 		return in;
  374. 	}
  375.  
  376. 	void test_string1()
  377. 	{
  378. 		string s1;
  379. 		string s2("hello world");
  380.  
  381. 		cout << s1.c_str() << endl;
  382. 		cout << s2.c_str() << endl;
  383.  
  384. 		s2[0]++;
  385. 		cout << s2.c_str() << endl;
  386. 	}
  387.  
  388. 	void test_string2()
  389. 	{
  390. 		string s1;
  391. 		string s2("hello world");
  392. 		string s3(s2);//经典的浅拷贝问题
  393. 		//对于自定义类型，去调用默认的拷贝构造，但由于空间是new出来的，所以s2和s3指向的空间是一样的
  394. 		//会造成两个问题：两次析构和修改的时候互相影响
  395. 		//如何深拷贝？先拷贝下来一块空间，再让值拷贝下来，再让被拷贝的对象指向这块空间
  396. 		cout << s1.c_str() << endl;
  397. 		cout << s2.c_str() << endl;
  398. 		cout << s3.c_str() << endl;
  399.  
  400. 		s1 = s3;//赋值和拷贝构造类似，默认生成的也是浅拷贝
  401. 		cout << s1.c_str() << endl;
  402. 		cout << s3.c_str() << endl;
  403. 	}
  404.  
  405. 	void Print(const string& s)//传值传参会调拷贝构造，也要深拷贝；const对象，调用的函数也要是const
  406. 	{
  407. 		for (size_t i = 0; i < s.size(); ++i)
  408. 		{
  409. 			cout << s[i] << " ";
  410. 		}
  411. 		cout << endl;
  412.  
  413.  
  414. 		string::const_iterator it = s.begin();//再使用范围for就OK了
  415. 		while (it != s.end())
  416. 		{
  417. 			//cout << (*it)-- << " ";只能读，不能写
  418. 			++it;
  419. 		}
  420. 		cout << endl;
  421.  
  422. 		/*for (auto ch : s)//这里就用不了了，因为范围for是替换的迭代器，这里用迭代器也不行，这里是const对象，而普通的迭代器会修改内容，权限被放大了
  423. 		{
  424. 			cout << ch << " ";
  425. 		}
  426. 		cout << endl;*/
  427.  
  428. 	}
  429.  
  430. 	void test_string3()
  431. 	{
  432. 		string s1("hello world");
  433. 		for (size_t i = 0; i < s1.size(); ++i)
  434. 		{
  435. 			s1[i]++;
  436. 		}
  437. 		cout << endl;
  438. 		Print(s1);
  439.  
  440. 		string::iterator it = s1.begin();
  441. 		while (it != s1.end())
  442. 		{
  443. 			cout << (*it)-- << " ";
  444. 			++it;
  445. 		}
  446. 		cout << endl;
  447.  
  448. 		it = s1.begin();
  449. 		while (it != s1.end())
  450. 		{
  451. 			cout << *it << " ";
  452. 			++it;
  453. 		}
  454. 		cout << endl;
  455.  
  456. 		for (auto ch : s1)//实现了迭代器就能用范围for，因为它的底层就是宏，替换的迭代器，迭代器begin改成Begin就不能用范围for了
  457. 		{
  458. 			cout << ch << " ";
  459. 		}
  460. 		cout << endl;
  461. 	}
  462.  
  463. 	void test_string4()
  464. 	{
  465. 		string s1("hello world");
  466. 		string s2("hello world");
  467. 		string s3("xx");
  468.  
  469. 		cout << (s1 < s2) << endl;//比较ascii码
  470. 		cout << (s1 == s2) << endl;
  471. 		cout << (s1 >= s2) << endl;
  472. 	}
  473.  
  474. 	void test_string5()
  475. 	{
  476. 		string s1("hello world");
  477. 		//s1.push_back(' ');
  478. 		//s1.append("xxxxxxxxxxxxxxxxxxxx");
  479.  
  480.  
  481. 		s1 += ' ';
  482. 		s1 += "xxxxxxxxxxxxxxxxx";
  483. 		cout << s1.c_str() << endl;
  484.  
  485. 		s1.insert(5, 'x');
  486. 		cout << s1.c_str() << endl;
  487. 	}
  488.  
  489. 	void test_string6()
  490. 	{
  491. 		string s1("hello world111111111111111111111111");
  492. 		cout << s1.capacity() << endl;
  493. 		s1.reserve(10);
  494. 		cout << s1.capacity() << endl;
  495. 	}
  496.  
  497. 	void test_string7()
  498. 	{
  499. 		string s1;
  500. 		s1.resize(20, 'x');
  501. 		cout << s1.c_str() << endl;
  502. 		s1.resize(30, 'y');
  503. 		cout << s1.c_str() << endl;
  504.  
  505. 		s1.resize(10);
  506. 		cout << s1.c_str() << endl;
  507. 	}
  508.  
  509. 	void test_string8()
  510. 	{
  511. 		string s1("hello world");
  512. 		s1.insert(0, 'x');
  513. 		cout << s1.c_str() << endl;
  514. 		s1.insert(0, "yyy");
  515. 		cout << s1.c_str() << endl;
  516.  
  517. 		s1.erase(5, 1);
  518. 		cout << s1.c_str() << endl;
  519. 		s1.erase(5, 30);
  520. 		cout << s1.c_str() << endl;
  521.  
  522. 	}
  523. 	//流插入重载必须实现成友元函数？不对,没有访问类中的成员，不需要
  524. 	void test_string9()
  525. 	{
  526. 		string s1("hello world");
  527. 		s1 += '\0';
  528. 		s1 += "xxxxxxxxx";
  529. 		cout << s1 << endl;
  530. 		cout << s1.c_str() << endl;
  531.  
  532. 		string s2;
  533. 		cin >> s2;
  534. 		cout << s2 << endl;
  535. 	}
  536.  
  537. }

总结：

细节很多，后面的容器实现大部分类似，但还需要复习。

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/很楠不爱3/article/detail/705221
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号