【C++】string的实现

1.前言

前面我们说了string的使用，接下来我们就来自己实现一下string，让我们对string的理解更加深刻—>>点击查看《string的使用》

2. 框架了解

我们知道，stl容器都是使用模板来实现的，但是我们这里先不使用模板来实现，模板主要是涉及编码的问题，我们这里先不涉及那么多编码的问题，所以我们还是定义成了string.h和string.cpp以及测试test.cpp三个文件，声明和定义分离，如果是模板的话就不能声明和定义分离了

3.具体实现

1. 基本结构

字符串对我们来说就好像字符数组，所以我们底层其实是用一个字符类型的顺序表来实现的（这里为了跟标准库内的string区分开，我们使用自己的命名空间）

1. namespace William
2. {
3. class string
4. {
5. public:
7. private:
8. char* _str;
9. size_t _size;
10. size_t _capacity;
11. public:
12. static size_t npos;
13. };

复制代码

1. 这里其实就跟我们顺序表的架构是差不多的，只不过这里的数据类型是char类型
2. 这里的容量和大小因为都不可能为负数，所以类型使用的是size_t
3. 这里的npos我们后续会继续说

2. 构造函数

1. string()
2. :_str(new char[1]{'\0'})
3. ,_size(0)
4. ,_capacity(0)
5. {}
7. string(const char* str)
8. {
9. _size = strlen(str);
10. //_capacity不包含\0
11. _capacity = _size;
12. _str = new char[_capacity + 1];
13. strcpy(_str, str);
14. }

复制代码

1. 在这里的无参构造函数中，我们注意到_str初始化时进行了new，这里是为了适配c_str，防止解引用空指针，用nullptr是会崩溃的
2. 我们要知道这里的_capacity是不包含\0的，但是我们是需要把\0存起来的，所以我们new的时候空间是要加一的
3. 而且这里也要注意我们初始化列表的顺序，这需要结合我们之前的类和对象知识，初始化列表中按照成员变量在类中声明顺序进行初始化，跟成员在初始化列表出现的先后顺序无关。所以这里带参的构造函数也可以不走初始化列表初始化

下面我们可以把这两个构造函数合并成一个带缺省参数的构造函数

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

复制代码

3. 析构函数

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

复制代码

1. 前面我们使用的是new[]，所以我们这里的delete就要使用delete[]
2. 析构之前要看看字符串是否为空，如果为空就不需要析构
3. delete之后要把_str指向空指针，容量和大小要清空

4. 拷贝构造函数

1. 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. }

复制代码

1. 我们之前在类和对象里面知道，只要一个对象有显式实现的析构函数，那么就要实现深拷贝
2. 这里的容量加一还是为了存放\0
3. 注意我们这里的拷贝构造和后面的赋值运算符重载都是有现代写法的，我们说的都是传统写法，现代写法可以去最下面我们的源代码那里查看

5. size()以及capacity()

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

复制代码

1. 这里就跟构造函数那里说的一样，容量和大小是不可能为负数的，所以我们使用了size_t类型
2. 我们这两个接口是肯定不允许用户修改的，所以我们使用了const进行了修饰

6. c_str

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

复制代码

1. 这个接口可以返回C语言形式的字符串
2. 这里实现了两个，区别就是一个是对于普通对象的一个是针对const对象的，而无论是哪种对象，我们都是不希望用户修改我们的原始字符串的，使用我们返回是也使用了const

测试

1. void test_string1()
2. {
3. string s1;
4. string s2("hello world");
5. cout << s1.c_str() << endl;
6. cout << s2.c_str() << endl;
7. }
8. int main()
9. {
10. William::test_string1();
11. return 0;
12. }

复制代码

关于这里的测试，还有一些知识需要大家回顾，就是关于声明和定义分离的相关知识，我们前面在框架那里说过，我们是创建了三个文件的，我们这里的测试是在test.cpp中实现的，但是我们要在string.h中声明，我们的string.cpp和test.cpp文件都会包含string.h这个头文件，如果我们在string.h中实现测试函数，那么在string.cpp和test.cpp中都会有一份这个测试函数，在最后链接的时候就会出现冲突

7. iterator迭代器实现

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

复制代码

1. 这里我们可以看到，string的迭代器底层就是字符指针
2. 这里我们分别实现了普通对象的迭代器和const对象的迭代器
3. 我们要知道，迭代器都是左闭右开的，所以我们这里的end其实指向的是最后一个元素的下一个位置
4. 编译器会根据对象的类型，自动选择最合适的迭代器，这个不需要我们担心

测试

1. void test_string1()
2. {
3. string s1;
4. string s2("hello world");
5. cout << s1.c_str() << endl;
6. cout << s2.c_str() << endl;
8. string::iterator it = s2.begin();
9. while (it != s2.end())
10. {
11. *it += 2;
12. cout << *it << " ";
13. ++it;
14. }
15. cout << endl;
17. for (auto ch : s2)
18. {
19. cout << ch << " ";
20. }
21. cout << endl;
22. }
24. int main()
25. {
26. William::test_string1();
27. return 0;
28. }

复制代码

这里我们可以看到，实现迭代器之后就可以支持范围for了

8. operator[]

这里因为[]运算符在string里面太重要了，所以我们这里单独拉出来说一下

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

复制代码

1. 我们重载了[]之后，string就可以像数组一样实现下标访问了，这是极其方便的
2. 这里我们也是重载了普通对象的和const对象的

测试

1. void test_string1()
2. {
3. string s1;
4. string s2("hello world");
5. cout << s1.c_str() << endl;
6. cout << s2.c_str() << endl;
8. for (size_t i = 0; i < s2.size(); i++)
9. {
10. s2[i] += 2;
11. }
12. cout << s2.c_str() << endl;
13. }
15. int main()
16. {
17. William::test_string1();
18. return 0;
19. }

复制代码

9. reserve

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

复制代码

1. 这个函数是我们扩容或者指定开辟空间大小的函数
2. 我们默认采取只扩容不缩容的策略
3. C++中的扩容不能像C语言中realloc那样，只能像这样先再开辟一块新空间，然后把原始字符串的内容给这个新空间拷贝过去，再让原始字符串的指针指向这个新空间
   4.注意，在这里及下面的接口中，只要是指明类域的就是我们在string.cpp文件中实现的函数，这里体现出我们一开始说的声明和定义分离

10. push_back、append和insert及operator+=

这四个接口都是实现了string中增加元素的功能

1. void string::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. }
12. string& string::operator+=(char ch)
13. {
14. push_back(ch);
15. return *this;
16. }
18. void string::append(const char* str)
19. {
20. size_t len = strlen(str);
21. if (_size + len > _capacity)
22. {
23. reserve(_size + len > 2 * _capacity ? _size + len : 2 * _capacity);
24. }
25. strcpy(_str + _size, str);
26. _size += len;
27. }
29. string& string::operator+=(const char* str)
30. {
31. append(str);
32. return *this;
33. }
35. void string::insert(size_t pos, char ch)
36. {
37. assert(pos < _size);
39. if (_size == _capacity)
40. {
41. reserve(_capacity == 0 ? 4 : _capacity * 2);
42. }
44. size_t end = _size + 1;
45. while (end > pos)//注意这里
46. {
47. _str[end] = _str[end - 1];
48. --end;
49. }
50. _str[pos] = ch;
51. ++_size;
52. }
54. void string::insert(size_t pos, const char* str)
55. {
56. assert(pos < _size);
58. size_t len = strlen(str);
59. if (len == 0) return;
61. if (_size + len > _capacity)
62. {
63. reserve(_size + len > 2 * _capacity ? _size + len : 2 * _capacity);
64. }
66. size_t end = _size + len;
67. while (end > pos + len - 1)//注意这里
68. {
69. _str[end] = _str[end - len];
70. --end;
71. }
73. for (int i = 0; i < len; i++)
74. {
75. _str[pos + i] = str[i];
76. }
78. _size += len;
79. }

复制代码

1. 首先我们要知道push_back接口是只能添加单个字符的，而其他接口是既可以添加字符也可以添加字符串
2. 在push_back中一定要注意最后要加上\0
3. 在这些接口中，我们都需要先看看容量是否足够，不够需要扩容，这里是通过reserve扩容的
4. 这些接口中，最需要注意的就是insert接口，因为在insert接口中它是需要挪动数据的，但是这个循环的判断条件极其容易出错，最核心的原因是我们定义的类型（size_t）的问题，我们的end是size_t类型，当它减到0时本应该跳出循环，但由于它的无符号类型，当它为0再减1时本应是-1，但是-1在内存中的补码全为1，对于无符号类型来说就直接变成最大值了，就会一直循环下去导致死循环，我们这里的end很多人都会写成直接等于_size，就会出现上述的错误，这里一定要记得end是等于_size+ 1的

测试

1. void test_string2()
2. {
3. string s1("hello world");
4. s1 += '+';
5. s1 += '*';
6. cout << s1.c_str() << endl;
8. s1 += "love";
9. cout << s1.c_str() << endl;
11. s1.insert(5, '&');
12. cout << s1.c_str() << endl;
14. string s2("hello world");
15. s2.insert(5, "&&&");
16. cout << s2.c_str() << endl;
17. }
19. int main()
20. {
22. William::test_string2();
23. return 0;
24. }

复制代码

我们注意到，我们的operator+=的实现是通过push_back和append的复用来实现的，所以我们这里直接测试+=和insert就行

11. erase

前面我们说了string中如何增加数据，现在我们来看看怎么减少数据

这是我们在头文件中的声明：

1. void erase(size_t pos, size_t len = npos);

复制代码

为什么要单独把这个说一下呢，因为我们可以看看这个声明中有一个明显不同的缺省参数npos，这就是我们在基本结构那里说的那个npos，这里我们就来说一下它的左右，在基本结构那里我们可以看到它是定义成了一个全局的变量，所以我们不能在头文件中把它初始化了，只能声明它，初始化是在string.cpp中实现的，如果我们在头文件中初始化就会发生链接错误，这个npos我们认为它是size_t类型的，我们把它赋值为-1，对于无符号来说这就是整型的最大值了，即我们这里的缺省参数的意义是默认删除到字符串结束
注：这里是需要结合我们的类和对象下中的static成员部分的内容来理解的，详情请看-——>>>点击查看《类和对象下》

其实这里直接在头文件中初始化npos也是可以的，算是C++对于这个东西单独开了一个绿灯，所以大家可能会在某些地方看到直接在头文件中初始化，对于这个npos来说确实可以编译通过，但是不建议大家这样写

1. void string::erase(size_t pos, size_t len)
2. {
3. assert(pos < _size);
5. if (len >= _size - pos)
6. {
7. _str[pos] = '\0';
8. _size = pos;
9. }
10. else
11. {
12. for (int i = pos + len; i <= _size; i++)
13. {
14. _str[i - len] = _str[i];
15. }
16. _size -= len;
17. }
18. }

复制代码

1. erase成员函数实现的是对pos位置处开始向后len个字符的删除
2. 我们通过上面对npos的讲解知道，如果没有传len的值，erase是默认删除到字符串结束的，而且我们要注意到没有在函数头这里再写一遍缺省参数，这是我们关于缺省参数的一个知识点>>>点击查看详情<<<
3. 这里的删除和我们的顺序表中的删除很类似，是不需要真的去把数据清空的，只是修改string对象的大小

测试

1. void test_string3()
2. {
3. string s1("hello world");
4. s1.erase(6, 100);
5. cout << s1.c_str() << endl;
7. string s2("hello world");
8. s2.erase(6);
9. cout << s2.c_str() << endl;
11. string s3("hello world");
12. s3.erase(6, 3);
13. cout << s3.c_str() << endl;
14. }
16. int main()
17. {
18. William::test_string3();
19. return 0;
20. }

复制代码

12. find

这是我们在头文件中的声明

1. size_t find(char ch, size_t pos = 0);
2. size_t find(const char* str, size_t pos = 0);

复制代码

1. size_t string::find(char ch, size_t pos)
2. {
3. assert(pos < _size);
4. for (int i = pos; i < _size; i++)
5. {
6. if (_str[i] == ch)
7. {
8. return i;
9. }
10. }
11. return npos;
12. }
14. size_t string::find(const char* str, size_t pos)
15. {
16. assert(pos < _size);
17. const char* ptr = strstr(_str + pos, str);
18. if (ptr == nullptr)
19. {
20. return npos;
21. }
22. else
23. {
24. return ptr - _str;
25. }
26. }

复制代码

1. find接口就是从pos位置开始查找指定字符或者字符串，如果没有指定pos，则从0位置开始查找，第一个就是查找字符，第二个是查找字符串
2. 这里我们采用的都是暴力匹配，像KMP算法之类的本人还没有那么高的水平，字符串匹配用的是C语言中的函数，这里也体现出我们当时适配C语言的重要性

测试

我们这里把find测试和接下来的substr以及赋值运算符放在一起展示了，这样更清晰一点

13. substr

这是我们在头文件中的声明

1. string substr(size_t pos = 0, size_t len = npos);

复制代码

1. string string::substr(size_t pos, size_t len)
2. {
3. assert(pos < _size);
4. if (len > _size - pos)
5. {
6. len = _size - pos;
7. }
9. string sub;
10. sub.reserve(len);
11. for (int i = 0; i < len; i++)
12. {
13. sub += _str[pos + i];
14. }
15. return sub;
16. }

复制代码

1. 我们这里的substr功能是从pos位置开始，获取len个字符长度的字串，这里我们从声明中可以知道pos和len都是有缺省值的，所以什么参数都不传的话，该接口会默认从字符串的起始位置开始一直到字符串结束，也就是整个字符串
2. 注意这里是需要理解我们拷贝构造的知识的，如果这里没有拷贝构造的话，程序是会崩溃的>>>点击查看拷贝构造相关知识<<<，这里我们就简单说一下，这里我们的传值返回是需要调用拷贝构造的，sub在出了函数之后就会销毁产生一个临时变量，我们需要用这个临时变量来拷贝构造我们的子串，如果我们没有显式实现拷贝构造没有实现深拷贝的话，随着sub的销毁子串也就让子串指向一个野指针了，而且不能引用返回，也是因为sub出了作用域就会销毁

测试

这里如上面find那里说的一样

14. 赋值运算符重载

通过上面substr中的注意事项中我们看到了拷贝构造的重要性，接下来我们就会实现一个跟拷贝构造容易搞混的默认成员函数——赋值运算符重载>>>点击查看赋值运算符重载详情<<<

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

复制代码

1. 这里的this指针就是要被赋值的对象，我们需要先把它给释放掉，再让它指向一块新空间，并把赋值的对象拷贝给要被赋值的对象
2. 需要注意的是，在语法层面上是允许自己给自己赋值的，所以我们一定要判断一下是不是自己给自己赋值，如果是且没有做判断的话，上来就把自己释放就出错了

测试

1. void test_string4()
2. {
3. string s("test.cpp.zip");
4. size_t pos = s.find('.');
5. string sub = s.substr(pos);
6. cout << sub.c_str() << endl;
8. string copy(s);
9. cout << copy.c_str() << endl;
11. s = sub;
12. cout << sub.c_str() << endl;
13. cout << s.c_str() << endl;
15. s = s;
16. cout << s.c_str() << endl;
17. }
19. int main()
20. {
21. William::test_string4();
22. return 0;
23. }

复制代码

15. 运算符重载

这是我们在头文件中的声明

1. bool operator<(const string& s1, const string& s2);
2. bool operator<=(const string& s1, const string& s2);
3. bool operator>(const string& s1, const string& s2);
4. bool operator>=(const string& s1, const string& s2);
5. bool operator==(const string& s1, const string& s2);
6. bool operator!=(const string& s1, const string& s2);

复制代码

这里我们并没有重载<<和>>，我们在下面会单独说这两个

1. bool operator<(const string& s1, const string& s2)
2. {
3. return strcmp(s1.c_str(), s2.c_str()) < 0;
4. }
6. bool operator<=(const string& s1, const string& s2)
7. {
8. return s1 < s2 || s1 == s2;
9. }
11. bool operator>(const string& s1, const string& s2)
12. {
13. return !(s1 <= s2);
14. }
16. bool operator>=(const string& s1, const string& s2)
17. {
18. return !(s1 < s2);
19. }
21. bool operator==(const string& s1, const string& s2)
22. {
23. return strcmp(s1.c_str(), s2.c_str()) == 0;
24. }
26. bool operator!=(const string& s1, const string& s2)
27. {
28. return !(s1 == s2);
29. }

复制代码

1. 我们这里是直接写成全局函数了，目的是跟库中一样可以支持字符串和字符串比以及字符和字符串比等，但是我们这里只实现了字符串与字符串比较，给大家先简单说明一下
2. 这里的比较我们只需要实现两个，剩下的就可以通过这两个复用来实现了

测试

1. void test_string5()
2. {
3. string s1("hello world");
4. string s2("hello world");
6. cout << (s1 < s2) << endl;
7. cout << (s1 == s2) << endl;
8. cout << ("hello world" < s2) << endl;//隐式类型转换
9. cout << (s1 == "hello world") << endl;//隐式类型转换
11. //这里没有隐式类型转换，运算符重载必须用一个类类型的参数
12. cout << ("hello world" == "hello world") << endl;
13. }
15. int main()
16. {
17. William::test_string5();
18. return 0;
19. }

复制代码

16. << 和 >> 重载

这是我们在头文件中的声明

1. ostream& operator<<(ostream& out, const string& s);
2. istream& operator>>(istream& in, string& s);//这里的istream是可以加const的

复制代码

重载完<<和>>之后我们在cout的时候就不用再调用c_str了

1. ostream& operator<<(ostream& out, const string& s)
2. {
3. for (auto ch : s)
4. {
5. out << ch;
6. }
7. return out;
8. }
10. istream& operator>>(istream& in, string& s)//这里的istream是可以加const的
11. {
12. s.clear();
14. //优化,防止频繁扩容
15. const int N = 256;
16. char buff[N];
17. int i = 0;
19. //这里由于istream直接流提取的特性，会直接忽略空格和换行，所以不能这样写
20. /*char ch;
21. in >> ch;
22. while (ch != ' ' && ch != '\n')
23. {
24. s += ch;
25. in >> ch;
26. }
27. return in;*/
29. char ch;
30. ch = in.get();
31. while (ch != ' ' && ch != '\n')
32. {
33. buff[i++] = ch;
34. if (i == N - 1)
35. {
36. buff[i] = '\0';
37. s += buff;
39. i = 0;
40. }
42. //s += ch;
43. ch = in.get();
44. }
46. if (i > 0)
47. {
48. buff[i] = '\0';
49. s += buff;
50. }
52. return in;
53. }

复制代码

1. << 和 >> 是必须要写成全局函数的，因为重载为成员函数this指针默认抢占了第一个形参位置，第一个形参位置是左侧运算对象，调用时就变成了对象<>>点击查看<<和>>重载详情
2. 正如我们在代码中的注释所说的一样，我们在实现>>重载的时候一定要注意使用get函数，否则会直接忽略空格和换行

测试

1. void test_string6()
2. {
3. string s("hello world");
4. cout << s << endl;
6. string str;
7. cin >> str;
8. cout << str << endl;
9. }
11. int main()
12. {
13. William::test_string6();
14. return 0;
15. }

复制代码

4. 源代码

1. string.h

1. #pragma once
2. #include<iostream>
3. #include<assert.h>
4. using namespace std;
6. namespace William
7. {
8. class string
9. {//短小频繁调用的函数，可以直接定义到类里面，默认是inline
10. public:
11. typedef char* iterator;
12. typedef const char* const_iterator;
14. iterator begin()
15. {
16. return _str;
17. }
19. iterator end()
20. {
21. return _str + _size;
22. }
24. const_iterator begin() const
25. {
26. return _str;
27. }
29. const_iterator end() const
30. {
31. return _str + _size;
32. }
34. //string()
35. // :_str(new char[1]{'\0'})
36. // ,_size(0)
37. // ,_capacity(0)
38. //{}
40. //string(const char* str)
41. //{
42. // _size = strlen(str);
43. // //_capacity不包含\0
44. // _capacity = _size;
45. // _str = new char[_capacity + 1];
46. // strcpy(_str, str);
47. //}
49. //上面两个构造合并到一起
50. string(const char* str = "")
51. {
52. _size = strlen(str);
53. _capacity = _size;
54. _str = new char[_capacity + 1];
55. strcpy(_str, str);
56. }
58. //传统写法
59. /*string(const string& s)
60. {
61. _str = new char[s._capacity + 1];
62. strcpy(_str, s._str);
63. _size = s._size;
64. _capacity = s._capacity;
65. }
66. string& operator=(const string& s)
67. {
68. if (this != &s)
69. {
70. delete[] _str;
71. _str = new char[s._capacity + 1];
72. strcpy(_str, s._str);
73. _size = s._size;
74. _capacity = s._capacity;
75. }
76. return *this;
77. }*/
79. //现代写法
80. void swap(string& s)
81. {
82. std::swap(_str, s._str);
83. std::swap(_size, s._size);
84. std::swap(_capacity, s._capacity);
85. }
86. string(const string& s)
87. {
88. string tmp(s._str);
89. swap(tmp);//直接用std中的swap会有3次深拷贝
90. }
91. //string& operator=(const string& s)
92. //{
93. // if (this != &s)
94. // {
95. // //string tmp(s._str);//调用构造
96. // string tmp(s);//调用拷贝构造
97. // swap(tmp);
98. // }
99. // return *this;
100. //}
101. string& operator=(string tmp)
102. {
103. swap(tmp);
104. return *this;
105. }
107. ~string()
108. {
109. if (_str)
110. {
111. delete[] _str;
112. _str = nullptr;
113. _size = _capacity = 0;
114. }
115. }
117. const char* c_str()
118. {
119. return _str;
120. }
122. const char* c_str() const
123. {
124. return _str;
125. }
127. void clear()
128. {
129. _str[0] = '\0';
130. _size = 0;
131. }
133. size_t size() const
134. {
135. return _size;
136. }
138. size_t capacity() const
139. {
140. return _capacity;
141. }
143. char& operator[](size_t pos)
144. {
145. assert(pos < _size);
146. return _str[pos];
147. }
149. const char& operator[](size_t pos) const
150. {
151. assert(pos < _size);
152. return _str[pos];
153. }
155. void reserve(size_t n);
156. void push_back(char ch);
157. void append(const char* str);
158. string& operator+=(char ch);
159. string& operator+=(const char* str);
161. void insert(size_t pos, char ch);
162. void insert(size_t pos, const char* str);
163. void erase(size_t pos, size_t len = npos);
165. size_t find(char ch, size_t pos = 0);
166. size_t find(const char* str, size_t pos = 0);
168. string substr(size_t pos = 0, size_t len = npos);
170. private:
171. char* _str = nullptr;
172. size_t _size = 0;
173. size_t _capacity = 0;
175. static const size_t npos;
176. };
178. bool operator<(const string& s1, const string& s2);
179. bool operator<=(const string& s1, const string& s2);
180. bool operator>(const string& s1, const string& s2);
181. bool operator>=(const string& s1, const string& s2);
182. bool operator==(const string& s1, const string& s2);
183. bool operator!=(const string& s1, const string& s2);
185. ostream& operator<<(ostream& out, const string& s);
186. istream& operator>>(istream& in, string& s);//这里的istream是可以加const的
187. }

复制代码

2. string.cpp

1. #define _CRT_SECURE_NO_WARNINGS
2. #include"string.h"
4. namespace William
5. {
6. const size_t string::npos = -1;
8. void string::reserve(size_t n)
9. {
10. if (n > _capacity)
11. {
12. char* tmp = new char[n + 1];
13. strcpy(tmp, _str);
14. delete[] _str;
15. _str = tmp;
16. _capacity = n;
17. }
18. }
20. void string::push_back(char ch)
21. {
22. if (_size == _capacity)
23. {
24. reserve(_capacity == 0 ? 4 :_capacity * 2);
25. }
26. _str[_size] = ch;
27. ++_size;
28. _str[_size] = '\0';
29. }
31. string& string::operator+=(char ch)
32. {
33. push_back(ch);
34. return *this;
35. }
37. void string::append(const char* str)
38. {
39. size_t len = strlen(str);
40. if (_size + len > _capacity)
41. {
42. reserve(_size + len > 2 * _capacity ? _size + len : 2 * _capacity);
43. }
44. strcpy(_str + _size, str);
45. _size += len;
46. }
48. string& string::operator+=(const char* str)
49. {
50. append(str);
51. return *this;
52. }
54. void string::insert(size_t pos, char ch)
55. {
56. assert(pos < _size);
58. if (_size == _capacity)
59. {
60. reserve(_capacity == 0 ? 4 : _capacity * 2);
61. }
63. size_t end = _size + 1;
64. while (end > pos)//注意这里
65. {
66. _str[end] = _str[end - 1];
67. --end;
68. }
69. _str[pos] = ch;
70. ++_size;
71. }
73. void string::insert(size_t pos, const char* str)
74. {
75. assert(pos < _size);
77. size_t len = strlen(str);
78. if (len == 0) return;
80. if (_size + len > _capacity)
81. {
82. reserve(_size + len > 2 * _capacity ? _size + len : 2 * _capacity);
83. }
85. size_t end = _size + len;
86. while (end > pos + len - 1)//注意这里
87. {
88. _str[end] = _str[end - len];
89. --end;
90. }
92. for (int i = 0; i < len; i++)
93. {
94. _str[pos + i] = str[i];
95. }
97. _size += len;
98. }
100. void string::erase(size_t pos, size_t len)
101. {
102. assert(pos < _size);
104. if (len >= _size - pos)
105. {
106. _str[pos] = '\0';
107. _size = pos;
108. }
109. else
110. {
111. for (int i = pos + len; i <= _size; i++)
112. {
113. _str[i - len] = _str[i];
114. }
115. _size -= len;
116. }
117. }
119. size_t string::find(char ch, size_t pos)
120. {
121. assert(pos < _size);
122. for (int i = pos; i < _size; i++)
123. {
124. if (_str[i] == ch)
125. {
126. return i;
127. }
128. }
129. return npos;
130. }
132. size_t string::find(const char* str, size_t pos)
133. {
134. assert(pos < _size);
135. const char* ptr = strstr(_str + pos, str);
136. if (ptr == nullptr)
137. {
138. return npos;
139. }
140. else
141. {
142. return ptr - _str;
143. }
144. }
146. string string::substr(size_t pos, size_t len)
147. {
148. assert(pos < _size);
149. if (len > _size - pos)
150. {
151. len = _size - pos;
152. }
154. string sub;
155. sub.reserve(len);
156. for (int i = 0; i < len; i++)
157. {
158. sub += _str[pos + i];
159. }
160. return sub;
161. }
163. bool operator<(const string& s1, const string& s2)
164. {
165. return strcmp(s1.c_str(), s2.c_str()) < 0;
166. }
168. bool operator<=(const string& s1, const string& s2)
169. {
170. return s1 < s2 || s1 == s2;
171. }
173. bool operator>(const string& s1, const string& s2)
174. {
175. return !(s1 <= s2);
176. }
178. bool operator>=(const string& s1, const string& s2)
179. {
180. return !(s1 < s2);
181. }
183. bool operator==(const string& s1, const string& s2)
184. {
185. return strcmp(s1.c_str(), s2.c_str()) == 0;
186. }
188. bool operator!=(const string& s1, const string& s2)
189. {
190. return !(s1 == s2);
191. }
193. ostream& operator<<(ostream& out, const string& s)
194. {
195. for (auto ch : s)
196. {
197. out << ch;
198. }
199. return out;
200. }
202. istream& operator>>(istream& in, string& s)//这里的istream是可以加const的
203. {
204. s.clear();
206. //优化,防止频繁扩容
207. const int N = 256;
208. char buff[N];
209. int i = 0;
211. //这里由于istream直接流提取的特性，会直接忽略空格和换行，所以不能这样写
212. /*char ch;
213. in >> ch;
214. while (ch != ' ' && ch != '\n')
215. {
216. s += ch;
217. in >> ch;
218. }
219. return in;*/
221. char ch;
222. ch = in.get();
223. while (ch != ' ' && ch != '\n')
224. {
225. buff[i++] = ch;
226. if (i == N - 1)
227. {
228. buff[i] = '\0';
229. s += buff;
231. i = 0;
232. }
234. //s += ch;
235. ch = in.get();
236. }
238. if (i > 0)
239. {
240. buff[i] = '\0';
241. s += buff;
242. }
244. return in;
245. }
246. }

复制代码

3. test.cpp

1. #define _CRT_SECURE_NO_WARNINGS
2. #include"string.h"
4. namespace William
5. {
6. void test_string1()
7. {
8. string s1;
9. string s2("hello world");
10. cout << s1.c_str() << endl;
11. cout << s2.c_str() << endl;
13. for (size_t i = 0; i < s2.size(); i++)
14. {
15. s2[i] += 2;
16. }
17. cout << s2.c_str() << endl;
19. string::iterator it = s2.begin();
20. while (it != s2.end())
21. {
22. *it += 2;
23. cout << *it << " ";
24. ++it;
25. }
26. cout << endl;
28. for (auto ch : s2)
29. {
30. cout << ch << " ";
31. }
32. cout << endl;
33. }
35. void test_string2()
36. {
37. string s1("hello world");
38. s1 += '+';
39. s1 += '*';
40. cout << s1.c_str() << endl;
42. s1 += "love";
43. cout << s1.c_str() << endl;
45. s1.insert(5, '&');
46. cout << s1.c_str() << endl;
48. string s2("hello world");
49. s2.insert(5, "&&&");
50. cout << s2.c_str() << endl;
51. }
53. void test_string3()
54. {
55. string s1("hello world");
56. s1.erase(6, 100);
57. cout << s1.c_str() << endl;
59. string s2("hello world");
60. s2.erase(6);
61. cout << s2.c_str() << endl;
63. string s3("hello world");
64. s3.erase(6, 3);
65. cout << s3.c_str() << endl;
66. }
68. void test_string4()
69. {
70. string s("test.cpp.zip");
71. size_t pos = s.find('.');
72. string sub = s.substr(pos);
73. cout << sub.c_str() << endl;
75. string copy(s);
76. cout << copy.c_str() << endl;
78. s = sub;
79. cout << sub.c_str() << endl;
80. cout << s.c_str() << endl;
82. s = s;
83. cout << s.c_str() << endl;
84. }
86. void test_string5()
87. {
88. string s1("hello world");
89. string s2("hello world");
91. cout << (s1 < s2) << endl;
92. cout << (s1 == s2) << endl;
93. cout << ("hello world" < s2) << endl;//隐式类型转换
94. cout << (s1 == "hello world") << endl;//隐式类型转换
96. //这里没有隐式类型转换，运算符重载必须用一个类类型的参数
97. cout << ("hello world" == "hello world") << endl;
98. }
100. void test_string6()
101. {
102. string s("hello world");
103. cout << s << endl;
105. string str;
106. cin >> str;
107. cout << str << endl;
108. }
109. }
111. int main()
112. {
113. //William::test_string1();
114. //William::test_string2();
115. //William::test_string3();
116. //William::test_string4();
117. //William::test_string5();
118. //William::test_string6();
119. return 0;
120. }

复制代码