C++初阶：适合新手的手撕string类（模拟实现string类）

上次讲了常用的接口：C++初阶：初识STL、String类接口详细讲解（万字解析）
今天就来进行模拟实现啦

---

---

先看一下大概有哪些部分：

1.基本结构与文件规划

• string.h头文件：包含类的全部(函数的声明与定义)
• test.cpp源文件：进行调用test函数，测试和完善功能

基本结构：

namespace MyString
{
	class string
	{
	public:
		//各种函数
	private:
		int _size;//有效字符的数量
		int _capacity;//开的空间大小
		char* _str;//没有设计成模版，就直接用char数组了
	};
}
1
2
3
4
5
6
7
8
9
10
11
12

2.构造函数（constructor)

2.1构造函数

2.1.1无参有参分开

		string()//空参的
		{
			_size = 0;
			_capacity = 0;
			_str = new char[1];
			_str[0] = '\0';
		}
		string(const char* str)
		{
			_size = strlen(str);
			_capacity = _size;
			_str = new char[_size + 1];//加一是给 \0
			strcpy(_str, str);
		}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

2.1.2利用缺省参数合起来

		string(const char* str="")//不是" "
		{
			_size = strlen(str);
			_capacity = _size;
			_str = new char[_size + 1];//加一是给 \0
			strcpy(_str, str);
		}
1
2
3
4
5
6
7

2.2拷贝构造

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

2.3模拟c_str()函数

目前还没有进行流插入和流提取的重构，只能利用这个来输出string里的内容

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

利用test1函数来看是否正确：

相同的命名空间会进行合并的

namespace MyString
{
	void test1()
	{
		string s1;
		cout << s1.c_str() << endl;
		string s2("abc");
		cout << s2.c_str() << endl;
		string s3(s2);
		cout << s3.c_str() << endl;

	}
}

int main()
{
	MyString::test1();
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

---

3.析构函数（destructor）

		~string()
		{
			_size = _capacity = 0;
			delete[] _str;
			_str = nullptr;
		}

1
2
3
4
5
6
7

---

4.operator=

		string& operator=(const string& s)//创建好新的空间（复制跟赋值）。再清理旧空间指向新的
		{
			char* tmp = new char[s._capacity+1];//创建好新空间
			strcpy(tmp, s._str);
			_size = s._size;
			_capacity = s._capacity;//复制跟赋值
			delete[] _str;
			_str = tmp;//清理，指向新的
			return *this;
		}
1
2
3
4
5
6
7
8
9
10

---

5.迭代器（iterator）

		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;
		}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

---

#6.capacity

6.1size()与capacity()

		size_t size()const
		{
			return _size;
		}

		size_t capacity()const
		{
			return _capacity;
		}
1
2
3
4
5
6
7
8
9

6.2 reserve()函数

		void reserve(size_t n)
		{
			if (n > _capacity)
			{
				_capacity = n;
				char* tmp = new char[_capacity + 1];
				strcpy(tmp, _str);
				delete[]_str;
				_str = tmp;//指向新的
			}
		}
1
2
3
4
5
6
7
8
9
10
11

namespace MyString
{
	void test2()
	{
		string s1;
		cout << s1.size() << endl;
		string s2("abc");
		cout << s2.size() << endl;
		string s3;
		s3 = s2;
		cout << s3.size() << endl;
		cout << s3.capacity() << endl;
	}
}

int main()
{
	MyString::test2();
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

---

7. modify

7.1push_back()、append()和operator+=

		void push_back(char c)
		{
			if (_size == _capacity)
			{
				int newCapacity = _capacity == 0 ? 4 : 2 * _capacity;//有可能是空参构造
				reserve(newCapacity);
			}
			_str[_size++] = c;
			_str[_size] = '\0';
		}

		void append(const char* str)
		{
			int len = strlen(str);
			if (len + _size > _capacity)
			{
				reserve(len + _size);
			}
			strcpy(_str + _size, str);
			_size += len;
		}

		string& operator+=(char c)
		{
			push_back(c);
			return *this;
		}

		string& operator+=(const char* str)
		{
			append(str);
			return *this;
		}
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

这里其实大家也能看到，二者一个用于字符的添加，一个用于字符串的添加。

其实就可以一个写成另外一个的重载

7.2clear()和swap()

		void clear()
		{
			_size = 0;
			_str[0] = '\0';
		}

		void swap(string& s)
		{
			std::swap(*this, s);//使用库里的swap
		}
1
2
3
4
5
6
7
8
9
10

对于swap，我们可以去使用库里面的，加上std：：就行了

namespace MyString
{
	void test3()
	{
		string s1("abc");
		cout << s1.c_str() << endl;
		s1 += 'a';
		cout << s1.c_str() << endl;
		s1 += "xxx";
		cout << s1.c_str() << endl;
	}
}

int main()
{
	MyString::test3();
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

---

8.access（operator[]）

		char& operator[](size_t index)
		{
			return _str[index];
		}

		const char& operator[](size_t index)const
		{
			return _str[index];
		}
1
2
3
4
5
6
7
8
9

一个用于非常量，一个用于常量

---

9.npos

namespace MyString
{
	class string
	{
	public:
		//各种函数
	private:
		int _size;//有效字符的数量
		int _capacity;//开的空间大小
		char* _str;//没有设计成模版，就直接用char数组了
        static size_t npos;
	};
    size_t string::npos = -1;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

---

10.find()函数

		// 返回c在string中第一次出现的位置
		size_t find(char c, size_t pos = 0) const//默认从0开始找
		{
			for (int i = 0; i < _size; i++)
			{
				if (_str[i] == c)
				{
					return i;
				}
			}
			return npos;
		}

		// 返回子串s在string中第一次出现的位置
		size_t find(const char* s, size_t pos = 0) const
		{
			char* ret = strstr(_str, s);//返回第一次出现的位置
			if (ret == nullptr)//没找到
			{
				return npos;
			}
			return ret - _str ;
		}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

namespace MyString
{
	void test4()
	{
		string s1("abc");
		cout << s1.find('a') << endl;
		cout << s1.find("bc");
	}
}

int main()
{
	MyString::test4();
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

---

11.insert()和erase()

		// 在pos位置上插入字符c/字符串str，并返回该字符的位置
		string& insert(size_t pos, char c)
		{
			if (_size = _capacity)//先看空间够不够
			{
				int newcapacity = _capacity == 0 ? 4 : 2 * _capacity;
				reserve(newcapacity);
			}
			//先向后移一格
			int end = _size;// \0也往后
			while (end >= (int)pos)//pos一般为size_t类型，此时，end会整型提升（有符号整数类型会被提升为无符号整数类型。）
			{
				_str[end + 1] = _str[end];
				end--;
			}
			_str[pos] = c;
			_size++;
			return *this;
		}

		string& insert(size_t pos, const char* str)
		{
			int len = strlen(str);
			if (_size +len>= _capacity)
			{
				reserve(_size + len);
			}
			//先向后移len个格
			int end = _size;// \0也往后
			while (end >= (int)pos)
			{
				_str[end + len] = _str[end];
				end--;
			}
			strncpy(_str + pos, str,len);
			_size += len;
			return *this;
		}

		// 删除pos位置上的元素，并返回该元素的下一个位置
		string& erase(size_t pos, size_t len= npos)
		{
			if (len == npos || len + pos >= _size)
			{
				_str[pos] = '\0';
				_size = pos;
			}
			else
			{
				int start = pos;
				while (_size - start - len+1 > 0)
				{
					_str[start] = _str[start + len];
					start++;
				}
			}
			return *this;
		}
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

测试：

namespace MyString
{
	void test5()
	{
		string s1("abc");
		cout << s1.c_str() << endl;
		int pos = s1.find("bc");
		s1.insert(pos, "xxx");
		cout << s1.c_str() << endl;
		s1.erase(pos,2);
		cout << s1.c_str() << endl;

	}
}

int main()
{
	MyString::test5();
	return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

---

#12.substr()函数

		string substr(size_t pos, size_t len = npos)
		{
			int end = pos + len;//end作为结束位置
			if (len == npos || pos + len >= _size)
			{
				end = _size;//当这两种情况，结束位置就是最后\0了
			}
			//开始pos到end赋值到新的一个空间，再返回
			string s;
			reserve(end - pos);
			for (int i = pos; i < end; i++)
			{
				s += _str[i];
			}
			return s;
		}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

---

13.operator<<和operator>>

	ostream& operator<<(ostream& out, string& s)//不需要放在类内，不需要是友元
	{
		for (auto e : s)
		{
			out << e;
		}
		return out;
	}

	istream& operator>>(istream& in, string& s)
	{
		s.clear();
		char ch = in.get();//使用cin拿不到空格和换行，二者其实还是字符，就用这个get
		while (ch != ' ' && 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

测试：

namespace MyString
{
	void test6()
	{
		string s1;
		cin >> s1;
		cout << s1 << endl;
		int pos = s1.find('b');
		string s2 = s1.substr(pos, 2);
		cout << s2 << endl;
	}
}

int main()
{
	MyString::test6();
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

---

好啦，今天就到这里啦，感谢大家支持！！！