C++---string类的使用和模拟实现_请设计一个str类,能模拟string类的部分操作: str s1; //建立一个空字符串 str

---

前言

今天我们来讲一将STL库中string类，因为有了string的支撑下，提供了许许多多的接口和一些运算符的重载，让我们实现起来许多项目和程序就变得容易起来了！
接下来就让我们看看
文章中的题的答案在最后结尾提供！！！

---

正文开始

一、 为什么学习string类？

1.1 C语言中的字符串

C语言中，字符串是以’\0’结尾的一些字符的集合，为了操作方便，C标准库中提供了一些str系列的库函数，
但是这些库函数与字符串是分离开的，不太符合OOP的思想，而且底层空间需要用户自己管理，稍不留神可
能还会越界访问。
OOP的核心思想：
面向对象的编程方法OOP是九十年代才流行的一种软件编程方法。它强调对象的“抽象”、“封装”、“继承”、“多态”。讲程序设计是由“数据结构”+“算法”组成的。从宏观的角度讲，OOP下的对象是以编程为中心的，是面向程序的对象。

1.2 两个面试题

字符串转整形数字
字符串相加

在OJ中，有关字符串的题目基本以string类的形式出现，而且在常规工作中，为了简单、方便、快捷，基本
都使用string类，很少有人去使用C库中的字符串操作函数。

二、标准库中的string类

2.1 string类(了解)

string类的文档介绍

1. 字符串是表示字符序列的类
2. 标准的字符串类提供了对此类对象的支持，其接口类似于标准字符容器的接口，但添加了专门用于操作
   单字节字符字符串的设计特性。
3. string类是使用char(即作为它的字符类型，使用它的默认char_traits和分配器类型(关于模板的更多信
   息，请参阅basic_string)。
4. string类是basic_string模板类的一个实例，它使用char来实例化basic_string模板类，并用char_traits
   和allocator作为basic_string的默认参数(根于更多的模板信息请参考basic_string)。
5. 注意，这个类独立于所使用的编码来处理字节:如果用来处理多字节或变长字符(如UTF-8)的序列，这个
   类的所有成员(如长度或大小)以及它的迭代器，将仍然按照字节(而不是实际编码的字符)来操作。

总结：

1. string是表示字符串的字符串类
2. 该类的接口与常规容器的接口基本相同，再添加了一些专门用来操作string的常规操作。
3. string在底层实际是：basic_string模板类的别名，typedef basic_string<char, char_traits, allocator>
   string;
4. 不能操作多字节或者变长字符的序列。
   >在使用string类时，必须包含#include头文件以及using namespace std;

2.2 string类的常用接口说明(最常用的)

1. string类对象的常见构造

void Teststring()
{
	 string s1; // 构造空的string类对象s1
	 string s2("hello bit"); // 用C格式字符串构造string类对象s2
	 string s3(s2); // 拷贝构造s3
	 string s4(10,'x');//构造10个x字符放入字符串
}
1
2
3
4
5
6
7

2. string类对象的容量操作

// size/clear/resize
void Teststring1()
{
	 // 注意：string类对象支持直接用cin和cout进行输入和输出
	 //因为内部已经重载<<和>>运算符
	 string s("hello, ROSE!!!");
	 cout << s.size() << endl;
	 cout << s.length() << endl;
	 cout << s.capacity() << endl;
	 cout << s <<endl;
	 
	 // 将s中的字符串清空，注意清空时只是将size清0，不改变底层空间的大小
	 s.clear();
	 cout << s.size() << endl;
	 cout << s.capacity() << endl;
	 // 将s中有效字符个数增加到10个，多出位置用'a'进行填充
	 // “aaaaaaaaaa”
	 s.resize(10, 'a');
	 cout << s.size() << endl;
	 cout << s.capacity() << endl;
	 // 将s中有效字符个数增加到15个，多出位置用缺省值'\0'进行填充
	 // "aaaaaaaaaa\0\0\0\0\0"
	 // 注意此时s中有效字符个数已经增加到15个
	 s.resize(15);
	 cout << s.size() << endl;
	 cout << s.capacity() << endl;
	 cout << s << endl;
	 // 将s中有效字符个数缩小到5个
	 s.resize(5);
	 cout << s.size() << endl;
	 cout << s.capacity() << endl;
	 cout << s << endl; 
}
//================================================================================

void Teststring2()
{
	 string s;
	 // 测试reserve是否会改变string中有效元素个数
	 s.reserve(100);
	 cout << s.size() << endl;
	 cout << s.capacity() << endl;
	 // 测试reserve参数小于string的底层空间大小时，是否会将空间缩小
	 s.reserve(50);
	 cout << s.size() << endl;
	 cout << s.capacity() << endl;
}
// 利用reserve提高插入数据的效率，避免增容带来的开销
//================================================================================

void TestPushBack()
{
	 string s;
	 size_t sz = s.capacity();
	 cout << "making s grow:\n";
	 for (int i = 0; i < 100; ++i)
	 {
		 s.push_back('c');
	 if (sz != s.capacity())
	 {
		 sz = s.capacity();
		 cout << "capacity changed: " << sz << '\n';
	 }
	 }
}
void TestPushBackReserve()
{
	 string s;
	 s.reserve(100);
	 size_t sz = s.capacity();
	 
	 cout << "making s grow:\n";
	 for (int i = 0; i < 100; ++i)
	 {
	 	s.push_back('c');
	 if (sz != s.capacity())
	 {
	 	sz = s.capacity();
	 	cout << "capacity changed: " << sz << '\n';
	 }
	 }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82

注意：

1. size()与length()方法底层实现原理完全相同，引入size()的原因是为了与其他容器的接口保持一
   致，一般情况下基本都是用size()。
2. clear()只是将string中有效字符清空，不改变底层空间大小。
3. resize(size_t n) 与 resize(size_t n, char c)都是将字符串中有效字符个数改变到n个，不同的是当字
   符个数增多时：resize(n)用0来填充多出的元素空间，resize(size_t n, char c)用字符c来填充多出的
   元素空间。注意：resize在改变元素个数时，如果是将元素个数增多，可能会改变底层容量的大
   小，如果是将元素个数减少，底层空间总大小不变。
4. reserve(size_t res_arg=0)：为string预留空间，不改变有效元素个数，当reserve的参数小于
   string的底层空间总大小时，reserver不会改变容量大小。

3.string类对象的访问及遍历操作

void Teststring()
{
	 string s1("hello Bit");
	 const string s2("Hello Bit");
	 cout<<s1<<" "<<s2<<endl;
	 cout<<s1[0]<<" "<<s2[0]<<endl;
	 
	 s1[0] = 'H';
	 cout<<s1<<endl;
	 
	 // s2[0] = 'h'; 代码编译失败，因为const类型对象不能修改
}
void Teststring()
{
	 string s("hello ROSE");
	 // 3种遍历方式：
	 // 需要注意的以下三种方式除了遍历string对象，还可以遍历是修改string中的字符，
	 // 另外以下三种方式对于string而言，第一种使用最多
	 // 1. for+operator[]
	 for(size_t i = 0; i < s.size(); ++i)
	 	cout<<s[i]<<endl;
	 
	 // 2.迭代器
	 string::iterator it = s.begin();
	 while(it != s.end())
	 {
		 cout<<*it<<endl;
		 ++it;
	 }
	 
	 string::reverse_iterator rit = s.rbegin();
	 while(rit != s.rend())
	 	cout<<*rit<<endl;
	 
	 // 3.范围for
	 for(auto ch : s)
	 	cout << ch << endl;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

4.string类对象的修改操作

**注意：

1. 在string尾部追加字符时，s.push_back© / s.append(1, c) / s += 'c’三种的实现方式差不多，一般
   情况下string类的+=操作用的比较多，+=操作不仅可以连接单个字符，还可以连接字符串。
2. 对string操作时，如果能够大概预估到放多少字符，可以先通过reserve把空间预留好。**

5.string类非成员函数

上面的几个接口大家了解一下，下面的OJ题目中会有一些体现他们的使用。string类中还有一些其他的
操作，这里不一一列举，大家在需要用到时不明白了查文档即可。

6. 牛刀小试

仅仅反转字母
找字符串中第一个只出现一次的字符
字符串里面最后一个单词的长度–
验证一个字符串是否是回文
字符串相加

三、string类的模拟实现

3.1 经典的string类问题

上面已经对string类进行了简单的介绍，大家只要能够正常使用即可。在面试中，面试官总喜欢让学生自己
来模拟实现string类，最主要是实现string类的构造、拷贝构造、赋值运算符重载以及析构函数。大家看下以
下string类的实现是否有问题？

namespace rose
{
	class string
	{
	public:
		/*string()
		:_str(new char[1])
		{*_str = '\0';}
		*/
		//string(const char* str = "\0") 错误示范
		//string(const char* str = nullptr) 错误示范
		string(const char* str = "")
		{
			// 构造string类对象时，如果传递nullptr指针，认为程序非法，此处断言下
			if (nullptr == str)
			{
				assert(false);
				return;
			}

			_str = new char[strlen(str) + 1];
			strcpy(_str, str);
		}

		~string()
		{
			if (_str)
			{
				delete[] _str;
				_str = nullptr;
			}
		}

	private:
		char* _str;
	};
	// 测试
	void Teststring()
	{
		string s1("hello bit!!!");
		string s2(s1);
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

系统崩溃了，这是为什么呢？

说明：上述string类没有显式定义其拷贝构造函数与赋值运算符重载，此时编译器会合成默认的，当用s1构 造s2时，编译器会调用默认的拷贝构造。最终导致的问题是，s1、s2共用同一块内存空间，在释放时同一块
空间被释放多次而引起程序崩溃，这种拷贝方式，称为浅拷贝

3.2 浅拷贝

浅拷贝：也称位拷贝，编译器只是将对象中的值拷贝过来。如果对象中管理资源，最后就会导致多个对象共
享同一份资源，当一个对象销毁时就会将该资源释放掉，而此时另一些对象不知道该资源已经被释放，以为
还有效，所以 当继续对资源进行操作时，就会发生发生了访问违规。要解决浅拷贝问题，C++中引入了深拷
贝。

3.3 深拷贝

如果一个类中涉及到资源的管理，其拷贝构造函数、赋值运算符重载以及析构函数必须要显式给出。一般情
况都是按照深拷贝方式提供。

3.3.1 传统版写法的string类

class string
{
public:
	string(const char* str = "")
	{
		// 构造string类对象时，如果传递nullptr指针，认为程序非法，此处断言下
		if (nullptr == str)
		{
			assert(false);
			return;
		}

		_str = new char[strlen(str) + 1];
		strcpy(_str, str);
 }

	 string(const string& s)
		 : _str(new char[strlen(s._str) + 1])
	 {
		 strcpy(_str, s._str);
	 }

	 string& operator=(const string& s)
	 {
		 if (this != &s)
		 {
			 char* pStr = new char[strlen(s._str) + 1];
			 strcpy(pStr, s._str);
			 delete[] _str;
			 _str = pStr;
		 }

		 return *this;
	 }

	 ~string()
	 {
		 if (_str)
		 {
			 delete[] _str;
			 _str = nullptr;
		 }
	 }
private:
	char* _str;
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

3.3.2 现代版写法的string类

class string
{
public:
	string(const char* str = "")
	{
		if (nullptr == str)
			str = "";
		_str = new char[strlen(str) + 1];
		strcpy(_str, str);
	}

	string(const string& s)
		: _str(nullptr)
	{
		string strTmp(s._str);
		swap(_str, strTmp._str);
	}

	// 对比下和上面的赋值那个实现比较好？
	string& operator=(string s)
	{
		swap(_str, s._str);
		return *this;
	}

	/*
	string& operator=(const string& s)
	{
	if(this != &s)
	{
		string strTmp(s);
		swap(_str, strTmp._str);
	}

	return *this;
	}
	*/

	~string()
	{
		if (_str)
		{
			delete[] _str;
			_str = nullptr;
		}
	}

private:
	char* _str;
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

3.3 写时拷贝(了解)

写时拷贝就是一种拖延症，是在浅拷贝的基础之上增加了引用计数的方式来实现的。
引用计数：用来记录资源使用者的个数。在构造时，将资源的计数给成1，每增加一个对象使用该资源，就给
计数增加1，当某个对象被销毁时，先给该计数减1，然后再检查是否需要释放资源，如果计数为1，说明该
对象时资源的最后一个使用者，将该资源释放；否则就不能释放，因为还有其他对象在使用该资源。
写时拷贝在读取是的缺陷

3.4 string类的模拟实现

namespace ROSE
{
	class string
	{
		//管理字符串的数组，可以增删查改
		//字符串结尾有'\0'
		//支持增删查改
	public:
		typedef char* iterator;
		typedef const char* const_iterator;
		iterator begin()
		{
			return _str;
		}
		iterator end()
		{
			return _str+_size;
		}
		const_iterator begin()const
		{
			return _str;
		}
		const_iterator end()const
		{
			return _str + _size;
		}
		string(const char* str = "")			
		{
			_size = strlen(str);
			_capacity = _size;
			_str = new char[_capacity + 1];
			strcpy(_str, str);
		}
		void swap(string& s)
		{
			::swap(_str, s._str);
			::swap(_size, s._size);
			::swap(_capacity, s._capacity);
		}
		//s1(s3)
		string(const string& s)    
			:_str(nullptr)
			,_size(0)
			,_capacity(0)
		{
			string tmp(s._str);
			//this->swap(tmp);
			swap(tmp);
		}
		//s1=s3;
		string& operator=(string s)
		{
			swap(s);
			return *this;
		}
		//遍历
		//at 作用和operator[]类似,越界抛异常
		//可读可写
		char& operator[](size_t i)
		{
			assert(i<_size);
			return _str[i];
		}
		//只读
		const char& operator[](size_t i)const							
		{
			assert(i < _size);
			return _str[i];
		}
		//成员函数的const修饰的是*this(本质是保护成员变量在函数体内不会被改变)
		//相当于是this指向的对象成员被保护，不能修改

		//开空间,扩展capacity
		void reserve(size_t n)
		{
			if (n > _capacity)
			{
				char* tmp = new char[n + 1];
				strncpy(tmp,_str,_size+1);
				delete[] _str;
				_str = tmp;
				_capacity = n;
			}
		}
		//开空间+初始化，扩展capacity并且初始化空间，size也要动
		void resize(size_t n,char val='\0')
		{
			if (n < _size)
			{
				_size = n;
				_str[_size] = '\0';
			}
			else
			{
				if (n > _capacity)
				{
					reserve(n);
				}
					memset(_str + _size, val, n - _size);
					_size = n;
					_str[_size] = '\0';
			}
		}
		void push_back(char ch)
		{
			/*if (_size == _capacity)
			{
				reserve(_capacity == 0 ? 4 : _capacity * 2);
			}
			_str[_size] = ch;
			_str[_size+1] = '\0';
			_size++; */

			insert(_size,ch);
		}
		void append(const char* str)
		{
			/*size_t len = _size + strlen(str);
			if (len > _capacity)
			{
				reserve(len);
			}
			strcpy(_str + _size, str);
			_size = len;*/
			insert(_size, str);
		}
		//s1 += 'x';
		string& operator+=(char ch)
		{
			push_back(ch);
			return *this;
		}
		//s1+='xxxxx';
		string& operator+=(const char* str)
		{
			append(str);
			return *this;
		}

		string& insert(size_t pos, char ch)
		{
			assert(pos <= _size);
			if (_size == _capacity)
			{ 
				reserve(_capacity==0?4: _capacity*2);
			}
			//不推荐
			/*for (int i = _size; i >=(int)pos; i--)
			{
				_str[i+1] = _str[i];
			}*/
			//for (size_t i = _size+1; i >pos; i--)
			//{
			//	_str[i] = _str[i-1];
			//}
			//或者还可以用指针
			char* end = _str + _size;
			while (end >= _str + pos)
			{
				*(end + 1) = *end;
				end--;
			}
			_str[pos] = ch;
			_size++;
			return *this;
		}
		//在pos位置之前插入
		string& insert(size_t pos,const char* str)
		{
			assert(pos <= _size);
			size_t len = strlen(str);
			if (_size + len > _capacity)
			{
				reserve(_size + len);
			}
			//挪动位置
			char* end = _str + _size;
			while (end >= _str+pos)
			{
				*(end + len) = *end;
				end--;
			}
			strncpy(_str+pos,str,len);
			_size += len;
			return *this;
		}
		string& erase(size_t pos = 0, size_t len=npos)
		{
			assert(pos < _size);
			size_t SubLen = _size - pos;
			//1.剩余的字符长度小于要删的长度（后面全部删完）
			if (len >= SubLen)
			{
				_str[pos] = '\0';
				_size = pos;
			}
			//2.剩余的字符长度大于要删的长度
			else
			{
				strcpy(_str + pos, _str + pos + len);
				_size -= len;
			}
			
			return *this;
		}

		size_t find(char ch,size_t pos=0)
		{
			assert(pos < _size);
			for (size_t i = pos; i < _size; i++)
			{
				if (_str[i] == ch)
					return i;
			}
			return npos;
		}
		size_t find(char* str, size_t pos=0)
		{
			assert(pos<_size);
			const char* ret=strstr(_str+pos,str);
			if (ret)
			{
				return ret - _str;
			}
			return npos;
		}

		void clear()
		{
			_size = 0;
			_str[0] = '\0';
		}
		size_t size()const
		{
			return _size;
		}
		~string()
		{
			delete[] _str;
			_str = nullptr;
			_size = _capacity = 0;
		}
		const char* c_str()const
		{
			return _str;
		}
	private:
		char* _str;
		size_t _size;
		size_t _capacity;
		const static size_t npos;
	};
	const size_t string::npos = -1;
	inline bool operator<(const string& s1,const string& s2)
	{
		return strcmp(s1.c_str(), s2.c_str()) < 0;
	}
	inline bool operator>(const string& s1, const string& s2)
	{
		return strcmp(s1.c_str(), s2.c_str()) > 0;
	}
	inline bool operator<=(const string& s1, const string& s2)
	{
		return !(s1>s2);
	}
	inline bool operator>=(const string& s1, const string& s2)
	{
		return !(s1<s2);
	}
	inline bool operator==(const string& s1, const string& s2)
	{
		return strcmp(s1.c_str(), s2.c_str()) == 0;
	}
	inline bool operator!=(const string& s1, const string& s2)
	{
		return !(s1==s2);
	}

	ostream& operator<<(ostream& out,const string& s)
	{
		for (auto ch : s)
		{
			out << ch;
		}
		return out;
	}
	istream& operator>>(istream& in,string& s)
	{
		s.clear();
		char ch;
		ch = in.get();
		while (ch != ' ' && ch != '\n')
		{
			s += ch;
			ch = in.get();
		}
		return in;
	}
	istream& getline(istream& in, string& s)
	{
		s.clear();
		char ch;
		ch = in.get();
		while (ch != '\n')
		{
			s += ch;
			ch = in.get();
		}
		return in;
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311

---

总结

例如：以上就是今天要讲的内容，本文仅仅简单介绍了string类的使用和模拟实现，文章中的题目答案可以存在码云仓库。链接如下~我的仓库