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

【C++】string类的模拟实现

作者：Gausst松鼠会 | 2024-05-15 14:33:30

赞

踩

【C++】string类的模拟实现

文章目录

一、string类的构造，拷贝构造，赋值重载以及析构

1.构造函数

2.拷贝构造

3.swap问题

4.赋值重载

5.析构函数

二.常用接口

1.c_str

2.operator[]

3.迭代器和范围for

4.size

三.插入

四.删除

五.查找

六.运算符重载

七.参考代码

string类的模拟实现我们定义三个成员变量

  1. 	class string
  2. 	{
  3. 	public:
  4. 		//...
  5. 	private:
  6. 		char* _str;
  7. 		size_t _size;
  8. 		size_t _capacity;
  9. 	};

下面对其中的成员函数进行依次的实现

一、string类的构造，拷贝构造，赋值重载以及析构

1.构造函数

构造函数分为无参和带参这两种

无参构造函数默认构造空字符串""，所以我们只需要写一个带参的并给一个缺省值即可

  1. string::string(const char* str)
  2. 	:_size(strlen(str))
  3. {
  4. 	_str = new char[_size + 1];
  5. 	_capacity = _size;
  6. 	strcpy(_str, str);
  7. }

注意：这里的_str开空间时要加1，是给\0预留位置

2.拷贝构造

对于string类型来说，如果不写拷贝构造会导致浅拷贝问题（只完成值拷贝）

所以我们需要进行深拷贝

这里先介绍一种传统写法，也是比较简单的写法

  1. string::string(const string& s)
  2. {
  3. 	_str = new char[s._capacity + 1];
  4. 	strcpy(_str, s._str);
  5. 	_size = s._size;
  6. 	_capacity = s._capacity;
  7. }

3.swap问题

在之前学习string的使用时，我们会发现明明std中就有swap，为什么string还要再实现一个？

这是因为第一个swap的交换代价比较大，它会进行深拷贝，造成空间损耗，所以我们在自己实现swap时要考虑到这一点，可以采用交换两者指针的方式：

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

4.赋值重载

默认生成的赋值重载也会导致浅拷贝，所以我们需要实现深拷贝

这里我们也用传统写法，也是比较简单的写法

  1. 	string& string::operator=(const string& s)
  2. 	{
  3. 		
  4. 		char* tmp = new char[s._capacity + 1];
  5. 		strcpy(tmp, s._str);
  6. 		delete[] _str;
  7. 		_str = tmp;
  8. 		_size = s._size;
  9. 		_capacity = s._capacity;
  10. 		
  11. 		return *this;
  12. 	}

其实还有一种现代写法，是复用上面的拷贝构造，感兴趣的小伙伴可以自行先去了解哦

5.析构函数

析构函数比较简单，请看下面的代码：

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

下面我们来看几个常用的接口实现

二.常用接口

1.c_str

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

2.operator[]

  1. char& string::operator[](size_t pos)//普通对象:可读可写
  2. {
  3. 	assert(pos < _size);
  4. 	return _str[pos];
  5. }

3.迭代器和范围for

迭代器

  1. typedef char* iterator;
  2. string::iterator string::begin()
  3. {
  4. 	return _str;
  5. }
  6. string::iterator string::end()
  7. {
  8. 	return _str + _size;
  9. }
  10.  
  11. //遍历
  12. string::iterator it1 = s1.begin();
  13. while (it1 != s1.end())
  14. {
  15. 	cout << *it1 << " ";
  16. 	++it1;
  17. }
  18. cout << endl;

范围for（底层还是迭代器）

  1. typedef char* iterator;
  2. string::iterator string::begin()
  3. {
  4. 	return _str;
  5. }
  6. string::iterator string::end()
  7. {
  8. 	return _str + _size;
  9. }
  10.  
  11. //遍历
  12. for (auto e: s1)
  13. {
  14. 	cout << e << " ";
  15. }
  16. cout << endl;

打印结果如下：

4.size

  1. size_t size() const
  2. {
  3.     return _size;
  4. }

三.插入

reserve

开辟新的空间，然后进行拷贝，对旧空间进行释放

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

push_back

尾插一个字符，我们需要考虑扩容问题

同时，尾插之后’\0’要重新处理

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

append

尾插字符串，这里我们需要计算，然后决定开多少空间（直接开2倍可能不够用）

  1. void string::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.  
  12. }

+=

这个比较简单，我们可以复用上面的分为+=字符和+=字符串push_back和append

  1. 	string& string::operator+=(char ch)//字符
  2. 	{
  3. 		push_back(ch);
  4. 	
  5. 		return *this;
  6. 	}
  7. 	
  8. 	string& string::operator+=(const char* str)//字符串
  9. 	{
  10. 		append(str);
  11. 	
  12. 		return *this;
  13. 	}

insert

insert的代码，我们要注意画图，尤其是关于边界的一些条件的处理，我们要小心

  1. 	void string::insert(size_t pos, char ch)//处理字符
  2. 	{
  3. 		assert(pos <= _size);
  4. 		if (_size == _capacity)
  5. 		{
  6. 			size_t newcapacity = _capacity == 0 ? 4 : _capacity * 2;
  7. 			reserve(newcapacity);
  8. 		}
  9.  
  10. 		size_t end = _size + 1;
  11. 		while (end > pos)//这里的边界要控制清楚！
  12. 		{
  13. 			_str[end] = _str[end - 1];//右移
  14. 			--end;
  15. 		}
  16.  
  17. 		_str[pos] = ch;
  18. 		++_size;
  19. 	}
  20.  
  21. 	void string::insert(size_t pos, const char* str)//处理字符串
  22. 	{
  23. 		assert(pos <= _size);
  24.  
  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.  
  38. 		memcpy(_str + pos, str, len);
  39. 		_size += len;
  40. 	}

四.删除

说到erase，自然要跟npos联系起来，npos是string类的静态成员变量

我们可以采用定义和声明分离的方法：

const static size_t npos;//写在string.h中

const size_t string::npos = -1;//写在string.cpp中

下面来实现这个删除功能：

  1. 	void string::erase(size_t pos, size_t len)
  2. 	{
  3. 		assert(pos < _size);
  4.  
  5. 		// len大于前面字符个数时，有多少删多少
  6. 		if (len >= _size - pos)
  7. 		{
  8. 			_str[pos] = '\0';
  9. 			_size = pos;
  10. 		}
  11.  
  12. 		else
  13. 		{
  14. 			strcpy(_str + pos, _str + pos + len);
  15. 			_size -= len;
  16. 		}
  17.  
  18. 	}

五.查找

从pos处开始查找字符或者字符串，找到返回下标值，没找到则返回npos

  1. 	size_t string::find(char ch, size_t pos)//字符
  2. 	{
  3. 		for (size_t i = pos; i < _size; i++)
  4. 		{
  5. 			if (_str[i] == ch)
  6. 			{
  7. 				return i;
  8. 			}
  9. 		}
  10. 	
  11. 		return npos;
  12. 	}
  13. 	
  14. 	size_t string::find(const char* sub, size_t pos)//字符串
  15. 	{
  16. 		char* p = strstr(_str + pos, sub);//调用现成的strstr来实现
  17. 		return  p - _str;
  18. 	}

六.流插入<<和流提取>>

流插入（输出）和流提取（输入）我们之前在日期类的时候也实现过了，我们知道它不适合写成 成员函数，之前我们用的是友元，这样才能访问私有，但这里我们可以不访问私有,挨个挨个遍历，所以可以这么写：

流插入<<

  1. 	ostream& operator<< (ostream& os, const string& str)//流插入(输出)
  2. 	{
  3. 		for (size_t i = 0; i < str.size(); i++)
  4. 		{
  5. 			os << str[i];
  6. 		}
  7.  
  8. 		return os;
  9. 	}

流提取>>

  1.    istream& operator>> (istream& is, string& str)//流提取(输入)
  2. {
  3. 	char ch = is.get();
  4. 	while (ch != ' ' && ch != '\n')
  5. 	{
  6. 		str += ch;
  7. 		ch = is.get();
  8. 	}
  9.  
  10. 	return is;
  11. }

但是这样还不够，我们会发现之前的数据它还留着：

所以我们需要再写个clear（）来清理数据：

  1. void string::clear()
  2. {
  3. 	_str[0] = '\0';
  4. 	_size = 0;
  5. }
  6.  
  7.  istream& operator>> (istream& is, string& str)//流提取(输入)
  8. 	{
  9. 		str.clear();
  10. 		char ch = is.get();
  11. 		while (ch != ' ' && ch != '\n')
  12. 		{
  13.            str += ch;
  14.            ch = is.get();
  15. 		}
  16.  
  17. 		return is;
  18. 	}

七.参考代码

这里模拟实现string类用了 string.h , string.cpp 和  test.cpp 三个文件来实现

这里给出string的各个函数定义和实现的代码

string.h

  1. #define _CRT_SECURE_NO_WARNINGS 1
  2. #pragma once
  3. #include <iostream>
  4. #include <assert.h>
  5. #include <string>
  6. using namespace std;
  7.  
  8. namespace bit
  9. {
  10. 	class string
  11. 	{
  12. 	public:
  13. 		typedef char* iterator;
  14. 		typedef const char* const_iterator;
  15.  
  16. 		iterator begin();
  17. 		iterator end();
  18.  
  19. 		const_iterator begin() const;
  20. 		const_iterator end() const;
  21.  
  22. 		string(const char* str = "");
  23. 		~string();
  24. 		const char* c_str() const;
  25.  
  26. 		size_t size() const;
  27. 		char& operator[](size_t pos);
  28. 		const char& operator[](size_t pos) const;
  29.  
  30. 		void push_back(char ch);
  31. 		void append(const char* str);
  32.  
  33. 	
  34.         void insert(size_t pos, char ch);
  35. 		void insert(size_t pos, const char* str);
  36. 		void reserve(size_t n);
  37. 		string& operator+=(char ch);
  38. 	    string& operator+=(const char* str);
  39. 	    void erase(size_t pos = 0, size_t len = npos);
  40.  
  41. 		string(const string& s);
  42. 		string& operator=(const string& s);
  43.  
  44. 		size_t find(char ch, size_t pos = 0);
  45. 		size_t find(const char* sub, size_t pos = 0);
  46.  
  47. 		void swap(string& s);
  48. 		string substr(size_t pos = 0, size_t len = npos);
  49.  
  50. 		bool operator<(const string& s) const;
  51. 		bool operator>(const string& s) const;
  52. 		bool operator<=(const string& s) const;
  53. 		bool operator>=(const string& s) const;
  54. 		bool operator==(const string& s) const;
  55. 		bool operator!=(const string& s) const;
  56. 		void clear();
  57.  
  58.  
  59. 	private:
  60. 		char* _str;
  61. 		size_t _size;
  62. 		size_t _capacity;
  63. 		const static size_t npos;
  64. 	};
  65.  
  66. 	istream& operator>> (istream& is, string& str);
  67.     ostream& operator<< (ostream& os, const string& str);
  68.  
  69. }

string.cpp

  1. #include "string.h"
  2.  
  3. namespace bit
  4. {
  5. 	const size_t string::npos = -1;
  6.  
  7. 	string::iterator string::begin()
  8. 	{
  9. 		return _str;
  10. 	}
  11.  
  12. 	string::iterator string::end()
  13. 	{
  14. 		return _str + _size;
  15. 	}
  16.  
  17. 	string::const_iterator string::begin() const
  18. 	{
  19. 		return _str;
  20. 	}
  21.  
  22. 	string::const_iterator string::end() const
  23. 	{
  24. 		return _str + _size;
  25. 	}
  26.  
  27.  
  28. 	string::string(const char* str)
  29. 		:_size(strlen(str))
  30. 	{
  31. 		_str = new char[_size + 1];
  32. 		_capacity = _size;
  33. 		strcpy(_str, str);
  34. 	}
  35.  
  36. 	string::string(const string& s)
  37. 	{
  38. 		_str = new char[s._capacity + 1];
  39. 		strcpy(_str, s._str);
  40. 		_size = s._size;
  41. 		_capacity = s._capacity;
  42. 	}
  43. 	
  44.  
  45. 	string::~string()
  46. 	{
  47. 		delete[] _str;
  48. 		_str = nullptr;
  49. 		_size = _capacity = 0;
  50. 	}
  51.  
  52. 	const char* string::c_str() const
  53. 	{
  54. 		return _str;
  55. 	}
  56.  
  57. 	size_t  string::size() const
  58. 	{
  59. 		return _size;
  60. 	}
  61.  
  62. 	string& string::operator=(const string& s)
  63. 	{
  64. 		if (this != &s)
  65. 		{
  66. 			char* tmp = new char[s._capacity + 1];
  67. 			strcpy(tmp, s._str);
  68. 			delete[] _str;
  69. 			_str = tmp;
  70. 			_size = s._size;
  71. 			_capacity = s._capacity;
  72. 		}
  73.  
  74. 		return *this;
  75. 	}
  76.  
  77. 	char& string::operator[](size_t pos)
  78. 	{
  79. 		assert(pos < _size);
  80. 		return _str[pos];
  81. 	}
  82.  
  83. 	const char& string::operator[](size_t pos) const
  84. 	{
  85. 		assert(pos < _size);
  86. 		return _str[pos];
  87. 	}
  88.  
  89. 	void string::reserve(size_t n)
  90. 	{
  91. 		if (n > _capacity)
  92. 		{
  93. 			char* tmp = new char[n + 1];
  94. 			strcpy(tmp, _str);
  95. 			delete[] _str;
  96.  
  97. 			_str = tmp;
  98. 			_capacity = n;
  99. 		}
  100. 	}
  101.  
  102. 	void string::insert(size_t pos, char ch)
  103. 	{
  104. 		assert(pos <= _size);
  105. 		if (_size == _capacity)
  106. 		{
  107. 			size_t newcapacity = _capacity == 0 ? 4 : _capacity * 2;
  108. 			reserve(newcapacity);
  109. 		}
  110.  
  111. 		size_t end = _size + 1;
  112. 		while (end > pos)
  113. 		{
  114. 			_str[end] = _str[end - 1];//右移
  115. 			--end;
  116. 		}
  117.  
  118. 		_str[pos] = ch;
  119. 		++_size;
  120. 	}
  121.  
  122. 	void string::insert(size_t pos, const char* str)
  123. 	{
  124. 		assert(pos <= _size);
  125.  
  126. 		size_t len = strlen(str);
  127. 		if (_size + len > _capacity)
  128. 		{
  129. 			reserve(_size + len);
  130. 		}
  131.  
  132. 		size_t end = _size + len;
  133. 		while (end > pos + len - 1)
  134. 		{
  135. 			_str[end] = _str[end - len];//右移
  136. 			--end;
  137. 		}
  138.  
  139. 		memcpy(_str + pos, str, len);
  140. 		_size += len;
  141. 	}
  142.  
  143. 	void string::push_back(char ch)
  144. 	{
  145. 		if (_size == _capacity)
  146. 		{
  147. 			size_t newcapacity = _capacity == 0 ? 4 : _capacity * 2;
  148. 			reserve(newcapacity);
  149. 		}
  150.  
  151. 		 _str[_size] = ch;
  152. 		 _str[_size + 1] = '\0';
  153. 		 ++_size;
  154.  
  155. 	}
  156.  
  157. 	void string::append(const char* str)
  158. 	{
  159. 		size_t len = strlen(str);
  160. 		if (_size + len > _capacity)
  161. 		{
  162. 			reserve(_size + len);
  163. 		}
  164.  
  165. 		strcpy(_str+_size, str);
  166. 		_size += len;
  167.  
  168. 	}
  169.  
  170. 	string& string::operator+=(char ch)
  171. 	{
  172. 		push_back(ch);
  173. 	
  174. 		return *this;
  175. 	}
  176. 	
  177. 	string& string::operator+=(const char* str)
  178. 	{
  179. 		append(str);
  180. 	
  181. 		return *this;
  182. 	}
  183. 	
  184. 	void string::erase(size_t pos, size_t len)
  185. 	{
  186. 		assert(pos < _size);
  187.  
  188. 		// len大于前面字符个数时，有多少删多少
  189. 		if (len >= _size - pos)
  190. 		{
  191. 			_str[pos] = '\0';
  192. 			_size = pos;
  193. 		}
  194.  
  195. 		else
  196. 		{
  197. 			strcpy(_str + pos, _str + pos + len);
  198. 			_size -= len;
  199. 		}
  200.  
  201. 	}
  202.  
  203. 	size_t string::find(char ch, size_t pos)
  204. 	{
  205. 		for (size_t i = pos; i < _size; i++)
  206. 		{
  207. 			if (_str[i] == ch)
  208. 			{
  209. 				return i;
  210. 			}
  211. 		}
  212. 	
  213. 		return npos;
  214. 	}
  215. 	
  216. 	size_t string::find(const char* sub, size_t pos)
  217. 	{
  218. 		char* p = strstr(_str + pos, sub);
  219. 		return  p - _str;
  220. 	}
  221.  
  222. 	void string::swap(string& s)
  223. 	{
  224. 		std::swap(_str, s._str);
  225. 		std::swap(_size, s._size);
  226. 		std::swap(_capacity, s._capacity);
  227. 	}
  228. 	
  229. 	string string::substr(size_t pos, size_t len)
  230. 	{
  231. 	    // len大于后面剩余字符，有多少取多少
  232. 		if (len > _size - pos)
  233. 		{
  234. 			string sub(_str + pos);//直接构造子串返回
  235. 			return sub;
  236. 		}
  237.  
  238. 		//len <= _size - pos
  239. 		else 
  240. 		{
  241. 			string sub;
  242. 			sub.reserve(len);
  243. 			for (size_t i = 0; i < len; i++)
  244. 			{
  245. 				sub += _str[pos + i];
  246. 			}
  247. 	
  248. 			return sub;
  249. 		}
  250.     }
  251. 	
  252.  
  253.     bool string::operator<(const string& s) const
  254. 	{
  255. 		return strcmp(_str, s._str) < 0;
  256. 	}
  257.  
  258. 	bool string::operator>(const string& s) const
  259. 	{
  260. 		return !(*this <= s);
  261. 	}
  262.  
  263. 	bool string::operator<=(const string& s) const
  264. 	{
  265. 		return *this < s || *this == s;
  266. 	}
  267.  
  268. 	bool string::operator>=(const string& s) const
  269. 	{
  270. 		return !(*this < s);
  271. 	}
  272.  
  273. 	bool string::operator==(const string& s) const
  274. 	{
  275. 		return strcmp(_str, s._str) == 0;
  276. 	}
  277.  
  278. 	bool string::operator!=(const string& s) const
  279. 	{
  280. 		return !(*this == s);
  281. 	}
  282.  
  283. 	void string::clear()
  284. 	{
  285. 		_str[0] = '\0';
  286. 		_size = 0;
  287. 	}
  288.  
  289.  
  290.     istream& operator>> (istream& is, string& str)
  291. 	{
  292. 		str.clear();
  293. 		char ch = is.get();
  294. 		while (ch != ' ' && ch != '\n')
  295. 		{
  296. 			str += ch;
  297. 			ch = is.get();
  298. 		}
  299.  
  300. 		return is;
  301. 	}
  302.  
  303. 	ostream& operator<< (ostream& os, const string& str)
  304. 	{
  305. 		for (size_t i = 0; i < str.size(); i++)
  306. 		{
  307. 			os << str[i];
  308. 		}
  309.  
  310. 		return os;
  311. 	}
  312.  
  313. }

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

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

  

闽ICP备14008679号