devbox
代码世界探险家
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

C++中string类的实现_c++ string代码实现

作者：代码世界探险家 | 2024-01-29 17:31:47

赞

踩

c++ string代码实现

1.c++库中的string类

在c++的标准库中我们处理字符串的时候需要使用string类，库中的使用接口都非常方便。

 为了让我们更加了解有关库中的相关函数，我们需要自己来实现一遍。

2.string类的实现

2.1类的构造和析构函数

  1.  
  2. 		string(const char* str = "")//构造函数
  3. 		{
  4. 			_size = strlen(str);
  5. 			_capacity = _size;
  6. 			_str = new char[_capacity + 1];
  7. 			memcpy(_str, str, _size + 1);
  8. 		}
  9.  
  10.      ~string()//析构函数
  11. 		{
  12. 			delete[] _str;
  13. 			_str = nullptr;
  14. 			_capacity = _size = 0;
  15. 		}
  16.

 在这里我们需要注意的是我们要使用c语言中的memcpy函数，因为在string类中的字符串是包含'\0'这样的字符的，而在c语言中，规则就是遇到\0就会停止，所以需要以string类中的size为准。

2.2运算符的重载

  1.         char& operator[](size_t pos)
  2. 		{
  3. 			assert(pos < _size);
  4. 			return _str[pos];
  5. 		}
  6.  
  7. 		const char& operator[](size_t pos) const
  8. 		{
  9. 			assert(pos < _size);
  10. 			return _str[pos];
  11. 		}
  12.         string& operator+=(char ch)
  13. 		{
  14. 			push_back(ch);
  15. 			return *this;
  16. 		}
  17.  
  18. 		string& operator+=(const char* str)
  19. 		{
  20. 			append(str);
  21. 			return *this;
  22. 		}
  23.

这里实现的是字符串的下标取值和字符串的添加，在字符串的函数添加中我们复用了push_back和append函数。

具体实现如下：

  1. void push_back(char ch)
  2. 		{
  3. 			if (_size == _capacity)
  4. 			{
  5. 				reserve(_capacity == 0 ? 4 : _capacity * 2);
  6. 			}
  7. 			_str[_size] = ch;
  8. 			_size++;
  9. 			_str[_size] = '\0';
  10.  
  11. 		}
  12.  
  13. 		void append(const char* str)
  14. 		{
  15. 			size_t len = strlen(str);
  16. 			if (len + _size > _capacity)
  17. 				reserve((len + _size) + 2);
  18. 			memcpy(_str + _size, str,len+1);
  19. 			_size += len;
  20. 		}

不管是尾插函数的实现还是扩展字符串的函数实现，我们都需要给字符串在必要的时候扩容，而这里在c++的标准库中提供一个叫reserve的函数，那我们就可以来实现一下。

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

这个函数就是在堆上开辟空间的，申请过后给一个临时指针，临时指针给str。

2.3迭代器的实现

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

string的迭代器就是指针的变型，所以当我们使用范围for也是可以的。

2.4流提取和流插入的重载

  1. ostream& operator<< (ostream& out, const string& s)//无法改变的字符串，所以需要加const
  2. 	{
  3. 		for (auto ch : s)
  4. 		{
  5. 			out << ch;
  6. 		}
  7.  
  8. 		return out;
  9. 	}
  10.  
  11. 	istream& operator >>(istream& in,  string& s)//输入的字符
  12. 	{
  13. 		s.clear();
  14. 		char ch = in.get();
  15. 		//消除字符缓存区的字符
  16. 		while (ch == ' ' || ch == '\n')
  17. 		{
  18. 			ch = in.get();
  19. 		}
  20. 		char buff[128];
  21. 		size_t i = 0;
  22. 		while (ch != ' ' && ch != '\n')
  23. 		{
  24. 			buff[i++] = ch;
  25. 			if (i == 127)
  26. 			{
  27. 				buff[i] = '\0';
  28. 				s += buff;
  29. 				i = 0;
  30.  
  31. 			}
  32. 			ch = in.get();
  33. 		}
  34.  
  35. 		if (i != 0)
  36. 		{
  37. 			buff[i] = '\0';
  38. 			s += buff;
  39. 		}
  40.  
  41. 		return in;

在之前的流提取的函数中，我们使用这个buff数组可以减少扩容的次数，是一种比较好的优化方案，只要buff数组被填满之后，我们就需要给重新置空，不会多次扩容。

2.5增删查改

  1. void erase(size_t pos, size_t len = npos)
  2. 		{
  3. 			assert(pos <= _size);
  4. 			if (len == npos || len + pos >= _size)
  5. 			{
  6. 				_str[pos] = '\0';
  7. 				_size = pos;
  8. 				_str[_size] = '\0';
  9. 			}
  10. 			else
  11. 			{
  12. 				size_t end = len + pos;
  13. 				while (end <= _size)
  14. 				{
  15. 					_str[pos++] = _str[end++];
  16. 				}
  17. 				_size -= len;
  18.  
  19. 			}
  20.  
  21. 		}
  22.  
  23.  
  24. 		size_t find(char ch, size_t pos = npos)
  25. 		{
  26. 			assert(pos <= _size);
  27. 			for (size_t i = pos; i < _size; i++)
  28. 			{
  29. 				if (ch == _str[i])
  30. 					return i;
  31. 			}
  32. 			return npos;
  33.  
  34. 		}
  35.  
  36. 		size_t find(const char* str, size_t pos = 0)
  37. 		{
  38. 			assert(pos < _size);
  39. 			const char* ptr = strstr(_str + pos, str);
  40. 			if (ptr)
  41. 			{
  42. 				return ptr - _str;
  43. 			}
  44. 			else
  45. 				return npos;
  46.  
  47. 		}
  48.  
  49. string substr(size_t pos = 0, size_t len = npos)
  50. 		{
  51. 			assert(pos < _size);
  52.  
  53. 			size_t n = len;
  54. 			if (len == npos || pos + len > _size)
  55. 			{
  56. 				n = _size - pos;
  57. 			}
  58.  
  59. 			string tmp;
  60. 			tmp.reserve(n + 2);
  61. 			for (size_t i = pos; i < pos + n; i++)
  62. 			{
  63. 				tmp += _str[i];
  64. 			}
  65.  
  66. 			return tmp;
  67. 		}
  68. void insert(size_t pos, size_t n, char ch)
  69. 		{
  70. 			assert(pos < _size);
  71. 			if (n + _size >= _capacity)
  72. 				reserve(n + _size + 2);
  73. 			int end = _size;
  74. 			//挪动数据
  75. 			while ((int)pos <= end)//当end减小到最小时会转换成很大的数，这里会隐式转换。//while(pos<=end&&end!=npos)
  76. 			{
  77. 				_str[end + n] = _str[end];
  78. 				end--;
  79. 			}
  80. 			for (size_t i = 0; i < n; i++)
  81. 			{
  82. 				_str[pos + i] = ch;
  83. 			}
  84. 			_size += n;
  85. 		}
  86.  
  87. 		void insert(size_t pos, const char* str)
  88. 		{
  89. 			assert(pos < _size);
  90. 			size_t len = strlen(str);
  91. 			size_t end = _size;
  92. 			if (len + _size > _capacity)
  93. 			{
  94. 				reserve(len + _size + 2);
  95. 			}
  96. 			while (pos <= end && end != npos)
  97. 			{
  98. 				_str[end + len] = _str[end];
  99. 				end--;
  100. 			}
  101. 			for (size_t i = 0; i < len; i++)
  102. 			{
  103. 				_str[pos + i] = str[i];
  104.  
  105. 			}
  106. 			_size += len;
  107. 		}

这里就是简单的函数实现的数据插入和查找，唯一需要注意的是insert的size_t和int的强转。

2.6字符串大小的比较函数重载

这一系列的函数其实只需要写几个函数，其余的只需要逻辑的互斥性就可以实现，非常容易。

  1. bool operator < (const string & s) const 
  2. 		{
  3. 			int ret = memcmp(_str, s._str, _size < s._size ? _size : s._size);//这里比较字符串的大小，将小的字符串长度来进行比较
  4.  
  5. 			return ret == 0 ? _size < s._size : ret < 0;//如果比较的长度一样长，注意三种情况
  6. 			//"world" 
  7. 			//"world" false
  8.  
  9. 			//"world"
  10.             //"worldxxx" true
  11.  
  12. 			//"worldxxx"
  13. 			//"world"      false 只有一种情况为真，_size<s._size
  14. 			
  15.  
  16. 		}
  17.  
  18. 		bool operator ==(const string& s) const
  19. 		{
  20. 			return _size == s._size &&
  21. 				memcmp(_str, s._str, s._size) == 0;
  22. 		}
  23.  
  24. 		bool operator <=(const string& s)const
  25. 		{
  26. 			return *this < s || *this == s;
  27. 		}
  28.  
  29. 		bool operator >(const string& s) const
  30. 		{
  31. 			return !(*this <= s);
  32. 		}
  33.  
  34. 		bool operator >=(const string& s)const
  35. 		{
  36. 			return !(*this < s);
  37. 		}

3.总代码

  1. #pragma once
  2. #include<iostream>
  3. #include<assert.h>
  4. using namespace std;
  5. namespace mystring
  6. {
  7. 	class string
  8. 	{
  9. 	public:
  10. 		/*string(const char* str="")
  11. 			:_size(strlen(str))
  12. 			;_capacity(_size)
  13. 			;_str(new char[_capacity + 1])
  14. 		{
  15. 			strcpy(_str, str);
  16. 		}*/
  17.  
  18.  
  19.  
  20. 		string(const char* str = "")//构造函数
  21. 		{
  22. 			_size = strlen(str);
  23. 			_capacity = _size;
  24. 			_str = new char[_capacity + 1];
  25. 			memcpy(_str, str, _size + 1);
  26. 		}
  27.  
  28. 		string(const string& str) //拷贝构造函数
  29. 		{
  30. 			_str = new char[str._capacity + 1];
  31. 			//strcpy(_str, str._str);
  32. 			memcpy(_str, str._str, str._size + 1);
  33. 			_size = str._size;
  34. 			_capacity = str._capacity;
  35. 		}
  36.  
  37. 		void swap(string &s)
  38. 		{
  39. 			std::swap(_size, s._size);
  40. 			std::swap(_capacity, s._capacity);
  41. 			std::swap(_str, s._str);
  42. 		}
  43.  
  44. 		string& operator =( string tmp)
  45. 		{
  46. 			swap(tmp);
  47. 			return *this;
  48. 		}
  49.  
  50. 		~string()//析构函数
  51. 		{
  52. 			delete[] _str;
  53. 			_str = nullptr;
  54. 			_capacity = _size = 0;
  55. 		}
  56.  
  57. 		const char* c_str()const
  58. 		{
  59. 			return _str;
  60. 		}
  61.  
  62. 		size_t size() const
  63. 		{
  64. 			return _size;
  65. 		}
  66.  
  67. 		char& operator[](size_t pos)
  68. 		{
  69. 			assert(pos < _size);
  70. 			return _str[pos];
  71. 		}
  72.  
  73. 		const char& operator[](size_t pos) const
  74. 		{
  75. 			assert(pos < _size);
  76. 			return _str[pos];
  77. 		}
  78.  
  79. 		void reserve(size_t n)
  80. 		{
  81.  
  82. 			if (n > _capacity)
  83. 			{
  84. 				char* tmp = new char[n];
  85. 				memcpy(tmp, _str,n);
  86. 				delete[] _str;
  87. 				_str = tmp;
  88. 				_capacity = n;
  89. 			}
  90. 		}
  91.  
  92. 		void push_back(char ch)
  93. 		{
  94. 			if (_size == _capacity)
  95. 			{
  96. 				reserve(_capacity == 0 ? 4 : _capacity * 2);
  97. 			}
  98. 			_str[_size] = ch;
  99. 			_size++;
  100. 			_str[_size] = '\0';
  101.  
  102. 		}
  103.  
  104. 		void append(const char* str)
  105. 		{
  106. 			size_t len = strlen(str);
  107. 			if (len + _size > _capacity)
  108. 				reserve((len + _size) + 2);
  109. 			memcpy(_str + _size, str,len+1);
  110. 			_size += len;
  111. 		}
  112.  
  113. 		string& operator+=(char ch)
  114. 		{
  115. 			push_back(ch);
  116. 			return *this;
  117. 		}
  118.  
  119. 		string& operator+=(const char* str)
  120. 		{
  121. 			append(str);
  122. 			return *this;
  123. 		}
  124.  
  125. 		void insert(size_t pos, size_t n, char ch)
  126. 		{
  127. 			assert(pos < _size);
  128. 			if (n + _size >= _capacity)
  129. 				reserve(n + _size + 2);
  130. 			int end = _size;
  131. 			//挪动数据
  132. 			while ((int)pos <= end)//当end减小到最小时会转换成很大的数，这里会隐式转换。//while(pos<=end&&end!=npos)
  133. 			{
  134. 				_str[end + n] = _str[end];
  135. 				end--;
  136. 			}
  137. 			for (size_t i = 0; i < n; i++)
  138. 			{
  139. 				_str[pos + i] = ch;
  140. 			}
  141. 			_size += n;
  142. 		}
  143.  
  144. 		void insert(size_t pos, const char* str)
  145. 		{
  146. 			assert(pos < _size);
  147. 			size_t len = strlen(str);
  148. 			size_t end = _size;
  149. 			if (len + _size > _capacity)
  150. 			{
  151. 				reserve(len + _size + 2);
  152. 			}
  153. 			while (pos <= end && end != npos)
  154. 			{
  155. 				_str[end + len] = _str[end];
  156. 				end--;
  157. 			}
  158. 			for (size_t i = 0; i < len; i++)
  159. 			{
  160. 				_str[pos + i] = str[i];
  161.  
  162. 			}
  163. 			_size += len;
  164. 		}
  165.  
  166. 		typedef char* iterator;
  167. 		typedef const char* const_iterator;
  168.  
  169. 		iterator end()
  170. 		{
  171. 			return _str + _size;
  172. 		}
  173.  
  174. 		iterator begin()
  175. 		{
  176. 			return _str;
  177. 		}
  178.  
  179. 		const_iterator end() const
  180. 		{
  181. 			return _str + _size;
  182. 		}
  183.  
  184. 		const_iterator begin() const
  185. 		{
  186. 			return _str;
  187. 		}
  188.  
  189.  
  190. 		void erase(size_t pos, size_t len = npos)
  191. 		{
  192. 			assert(pos <= _size);
  193. 			if (len == npos || len + pos >= _size)
  194. 			{
  195. 				_str[pos] = '\0';
  196. 				_size = pos;
  197. 				_str[_size] = '\0';
  198. 			}
  199. 			else
  200. 			{
  201. 				size_t end = len + pos;
  202. 				while (end <= _size)
  203. 				{
  204. 					_str[pos++] = _str[end++];
  205. 				}
  206. 				_size -= len;
  207.  
  208. 			}
  209.  
  210. 		}
  211.  
  212.  
  213. 		size_t find(char ch, size_t pos = npos)
  214. 		{
  215. 			assert(pos <= _size);
  216. 			for (size_t i = pos; i < _size; i++)
  217. 			{
  218. 				if (ch == _str[i])
  219. 					return i;
  220. 			}
  221. 			return npos;
  222.  
  223. 		}
  224.  
  225. 		size_t find(const char* str, size_t pos = 0)
  226. 		{
  227. 			assert(pos < _size);
  228. 			const char* ptr = strstr(_str + pos, str);
  229. 			if (ptr)
  230. 			{
  231. 				return ptr - _str;
  232. 			}
  233. 			else
  234. 				return npos;
  235.  
  236. 		}
  237.  
  238. 		/*string substr(size_t pos=0, size_t len=npos)
  239. 		{
  240. 			assert(pos <= _size);
  241. 			size_t n=len;
  242. 			if (len == npos || pos + len >= _size)
  243. 			{
  244. 				 n = _size - pos;
  245. 			}
  246. 			string tmp;
  247. 			reserve(n);
  248. 			for (int i = 0; i < n; i++)
  249. 			{
  250. 				tmp += _str[pos + i];
  251. 			}
  252. 			return tmp;
  256. 		}*/
  257.  
  258. 		string substr(size_t pos = 0, size_t len = npos)
  259. 		{
  260. 			assert(pos < _size);
  261.  
  262. 			size_t n = len;
  263. 			if (len == npos || pos + len > _size)
  264. 			{
  265. 				n = _size - pos;
  266. 			}
  267.  
  268. 			string tmp;
  269. 			tmp.reserve(n + 2);
  270. 			for (size_t i = pos; i < pos + n; i++)
  271. 			{
  272. 				tmp += _str[i];
  273. 			}
  274.  
  275. 			return tmp;
  276. 		}
  277.  
  278. 		void clear()
  279. 		{
  280. 			_str[_size] = '\0';
  281. 			_size = 0;
  282. 		}
  283.  
  284. 		bool operator < (const string & s) const 
  285. 		{
  286. 			int ret = memcmp(_str, s._str, _size < s._size ? _size : s._size);//这里比较字符串的大小，将小的字符串长度来进行比较
  287.  
  288. 			return ret == 0 ? _size < s._size : ret < 0;//如果比较的长度一样长，注意三种情况
  289. 			//"world" 
  290. 			//"world" false
  291.  
  292. 			//"world"
  293.             //"worldxxx" true
  294.  
  295. 			//"worldxxx"
  296. 			//"world"      false 只有一种情况为真，_size<s._size
  297. 			
  298.  
  299. 		}
  300.  
  301. 		bool operator ==(const string& s) const
  302. 		{
  303. 			return _size == s._size &&
  304. 				memcmp(_str, s._str, s._size) == 0;
  305. 		}
  306.  
  307. 		bool operator <=(const string& s)const
  308. 		{
  309. 			return *this < s || *this == s;
  310. 		}
  311.  
  312. 		bool operator >(const string& s) const
  313. 		{
  314. 			return !(*this <= s);
  315. 		}
  316.  
  317. 		bool operator >=(const string& s)const
  318. 		{
  319. 			return !(*this < s);
  320. 		}
  321. 		
  322.  
  323. 		static const size_t npos;
  324.  
  325.  
  326.  
  327. 	private:
  328. 		size_t _size;
  329. 		size_t _capacity;
  330. 		char* _str;
  331. 	};
  332.  
  333. 	const size_t string::npos = -1;
  334. 	//实现流的提取和插入
  335. 	ostream& operator<< (ostream& out, const string& s)//无法改变的字符串，所以需要加const
  336. 	{
  337. 		for (auto ch : s)
  338. 		{
  339. 			out << ch;
  340. 		}
  341.  
  342. 		return out;
  343. 	}
  344.  
  345. 	istream& operator >>(istream& in,  string& s)//输入的字符
  346. 	{
  347. 		s.clear();
  348. 		char ch = in.get();
  349. 		//消除字符缓存区的字符
  350. 		while (ch == ' ' || ch == '\n')
  351. 		{
  352. 			ch = in.get();
  353. 		}
  354. 		char buff[128];
  355. 		size_t i = 0;
  356. 		while (ch != ' ' && ch != '\n')
  357. 		{
  358. 			buff[i++] = ch;
  359. 			if (i == 127)
  360. 			{
  361. 				buff[i] = '\0';
  362. 				s += buff;
  363. 				i = 0;
  364.  
  365. 			}
  366. 			ch = in.get();
  367. 		}
  368.  
  369. 		if (i != 0)
  370. 		{
  371. 			buff[i] = '\0';
  372. 			s += buff;
  373. 		}
  374.  
  375. 		return in;
  376.  
  377. 	}
  378.  
  379.  
  380. }
  381.  
  382.

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

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

  

闽ICP备14008679号