C++string的模拟实现

C++string的模拟实现
· CSDN的uu们，大家好。这里是C++入门的第十六讲。
· 座右铭：前路坎坷，披荆斩棘，扶摇直上。
· 博客主页： @姬如祎
· 收录专栏：C++专题

目录

1. string类的成员变量

2. 构造函数

3. 析构函数

4. const char* c_str() const

5. size_t size() const

6. char& operator[](size_t pos)

7. void reserve(size_ t n)

8. void push_back(char ch)

9. void append(const char* s)

编辑

10. operator+=

10.1 string& operator+=(char ch)

10.2 string& operator+=(const char* s)

11. insert()

编辑

11.1 void insert(size_t pos, size_t n, char ch)

11.2 void insert(size_t pos, const char* s)

12. void erase(size_t pos, size_t len = npos)

13. find()

13.1 size_t find(char ch, size_t pos = 0)

13.2 size_t find(const char* s, size_t pos = 0)

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

15. void resize(size_ t n, char ch = '\0')

16. void clear()

17. 比较运算符的重载

17.1 bool operator<(cons string& s) const

17.2 bool operator==(cons string& s) const

17.3 接下来全部都是复用啦

18. ostream& operator<<(ostream& out, const string& s)

19. istream& operator>>(istream& in, string& s)

20. 拷贝构造函数

20.1 传统写法

20.2 现代写法

21. void swap(string& s)

22. 赋值运算符重载

23. string迭代器的实现

在上一讲，我们学习了如何使用string类。这节课我们将用一种叫较为简单的方式模拟实现一个string类。目的是加深对string类的理解。

1. string类的成员变量

在string类的使用那一节我们就已经知道了string类其实维护了一个char数组，一个表示char数组实际大小的size和一个表示数组真实容量的capacity，因此，我们模拟实现的string类的成员变量就是这三个啦！

因为string维护的char数组不是静态的，因此string类维护的是一个char*的指针，size表征有效字符的个数。维护capacity方便扩容。
```
namespace Tchey
{
	class string
	{
	private:
		char* _str;
		size_t _size;
		size_t _capacity;
	};
}
```
我们就定义出了一个基础的string类，在string类的定义外套一层明明空间主要是为了和库里面的string冲突哈！

2. 构造函数

我们也是看到string的构造函数是非常多的啊！我们就实现一个：string(const char* s)的版本就行啦！

该构造函数可以使用一个字符串常量构造一个string对象！我们在用传入的字符串常量构造string对象时，不能将形参s直接赋值给成员变量_str。而是需要在堆上开辟一块空间，然后将字符串常量的数据拷贝过去。同时初始化其他成员变量！

原因：

1：形参s指向的空间是常量区，不允许修改，后续对string对象的操作可能报错！

2：如果构造出来的string对象将空间释放，那么就会释放常量区的空间，非法操作！
```
string(const char* s)
{
	int len = strlen(s); //计算字符串常量的大小
	_str = new char[len + 1]; //开辟空间
	strcpy(_str, s); //拷贝数据
	_size = len; //修改其他成员变量
	_capacity = _size;
}
```
这里开辟 len + 1的空间是为了 strcpy 拷贝 ‘\0’ 预留的空间哈！为什么要有 '\0' 呢？不是有一个 _size 维护了字符串的大小嘛？那是因为string 有一个 c_str 接口，没有 '\0' 的话，没法兼容C语言啦！

在定义string对象的时候，我们可能会这么定义！上面的构造函数显然不能行。那怎么办呢？
```
string s;
```
在string的使用那一节我们讲到，直接这样定义string对象，在内存中其实是在下标为 0 的位置存储了一个 '\0' 的！因此，可以在上面我们写的构造函数给一个缺省参数！像这样：
```
string(const char* s = "")
{
	int len = strlen(s); //计算字符串常量的大小
	_str = new char[len + 1]; //开辟空间
	strcpy(_str, s); //拷贝数据
	_size = len; //修改其他成员变量
	_capacity = _size;
}
```
这样做是不是既简单右好理解呢？

3. 析构函数

构造函数写了，我们就可直接写出来析构函数啦！析构函数很好写：释放维护堆区空间的指针，将_size 和 _capacity 置为 0 即可！
```
~string()
{
	delete _str;
	_str = nullptr;
	_size = 0;
	_capacity = 0;
}
```
4. const char* c_str() const

这个函数返回C风格式的字符串嘛！很简单直接返回_str即可。后面的那个const修饰的是*this哈，代表成员变量不可修改！const对象与非const对象都可以调用！
```
const char* c_str() const
{
	return _str;
}
```
5. size_t size() const

返回字符串有效字符的数量！返回string类维护的_size即可！
```
size_t size() const
{
	return _size;
}
```
6. char& operator[](size_t pos)

为了使得我们的程序看起来比较健壮！因此我们可以检查一下pos的合法性，当我们的pos >= _size显然是不合法的！我们assert断言一下就可以啦！返回值就很好处理啦：返回pos位置的字符就行啦！注意到const的string对象也是可以调用operator[]的因此，我们还要实现一个const的版本：const char& operator[] const。方便const对象调用！const对象调用operator[]得到的字符不允许修改！
```
char& operator[](size_t pos)
{
	assert(pos < _size);
	return _str[pos];
}
 
//const版本
const char& operator[](size_t pos) const
{
	assert(pos < _size);
	return _str[pos];
}
```
7. void reserve(size_ t n)

这个函数是用来修改_str维护字符数组的真实容量的，我们需要做的就是：当n > _capacity的时候，开一块容量为n的空间，然后将原来空间的数据拷贝过去，然后在释放_str，在修改_str的指向，使其维护新开出来的空间！
```
void reserve(size_t n)
{
	if (n > _capacity)
	{
		char* tmp = new char[n + 1];
		memcpy(tmp, _str, _size + 1);
		delete[] _str;
		_str = tmp;
		_capacity = n;
	}
}
```
这里为什么我们开辟的是 n + 1个字符的空间呢？主要是因为 '\0' 的缘故啊！因为我们的C++必须兼容C语言，所以string对象有效字符的结尾都必须有一个 '\0', 同理memcpy，copy的字节数也要比_size大一，也是因为'\0'的缘故！这里必须要用memcpy不允许使用strcpy，那是因为我们的字符串可能中间出现 '\0'，用strcpy就会导致数据拷贝不完整！

8. void push_back(char ch)

该函数可以在string的末尾追加一个字符，模拟实现的时候注意扩容逻辑就行了！什么时候扩容：就是当_size >= _capacity 的时候，我们就需要扩容啦！扩容很好办，直接调用我们的reserve接口就行啦！

还有一个问题就是我们reserve的空间是多大呢？这就取决于你的实现啦！我比较习惯与扩容到原来的两倍！但是有一个魔鬼细节：如果扩容的时候原string的容量就是0 ，扩容成两倍不就是相当于没有扩容嘛，因此我们还需要做一个if条件判断！
```
void push_back(char ch)
{
	if (_size >= _capacity)
	{
		reserve(_capacity == 0 ? 4 : _capacity * 2);
	}
	_str[_size++] = ch;
	_str[_size] = '\0';
}
```
9. void append(const char* s)

我们知道append的重载版本很多，为了简单，我们选择实现append一个常量字符串的版本。

首先，我们还是需要判断是否需要进行扩容！我们先求出常量字符串的长度 len，如果 _size + len > _capacity 就说明需要扩容！最后，我们直接调用 strcpy 将常量字符串中的字符拷贝到str里面就可以啦！strcpy默认是会拷贝 '\0' 的所以没有任何问题哈！注意修改_size的大小哦！
```
void append(const char* s)
{
	int len = strlen(s);
	if (_size + len > _capacity)
	{
		reserve(_size + len);
	}
	strcpy(_str + _size, s);
	_size += len;
}
```
10. operator+=

库里面重载了三个版本，我们实现两个版本就行啦，加等一个字符和加等一个常量字符串。

10.1 string& operator+=(char ch)

嘿嘿，很简单，直接调用 push_back() 就行啦！push_back() 会做好一切！
```
string& operator+=(char ch)
{
	push_back(ch);
	return *this;
}
```
10.2 string& operator+=(const char* s)

同样地，我们直接调用append接口就行啦！
```
string& operator+= (const char* s)
{
	append(s);
	return *this;
}
```
11. insert()

我们看到库里面重载的版本真的很多呢！我们实现两个版本：在pos位置插入n个字符ch和在pos位置插入一个常量字符串。

11.1 void insert(size_t pos, size_t n, char ch)

1：检查pos位置的合法性，pos应该是要 <= _size 的。

2：判断是否需要扩容？当 _size + n > _capacity 就需要扩容啦！至于扩容到多大，取决于你，我们选择效仿上面append的扩容逻辑，就扩容到刚好够！

3：挪动数据，既然是在pos位置前面插入字符，我们肯定要腾出来 n 个字符的位置撒！不然怎么插入呢！

我们来看看移动前后的数组对比，再来看如何移动：假设我们要在 pos 位置插入 3 个 'b'

根据示意图：我们知道要将pos位置及其之后的所有字符向后移动3个下标！我们可以初始化一个变量：end(或者其他名字)，指向_size的位置，因为我们的 '\0' 也要移动嘛。然后将下标为 end + n 的字符赋值为下标为 end 指向的字符，我们就完成了字符向后移动 3 个下标，然后让 end--。直到end < pos，因为pos位置的字符也需要移动嘛！

移动完成之后从pos位置开始向后填充 n 个字符就行啦！

但是，还是有一个问题！假如 pos == 0，在完成一个字符移动，end--之后与 pos 比较就会出问题。因为 int 类型与 size_t 类型一起运算的时候会发生整形提升！int 会被提升为 size_t 从而原本 end == -1 整形提升之后 end 就会变成无符号整形的最大值！从而导致循环无法结束！

解决办法：

1：在判断条件处将 pos 强转为 int。

2. 我们可以将 end == -1 的情况单独拿出来判断。我们在学习string的使用时不是引入了一个 npos 嘛，他就是有符号的 -1 无符号的最大值，现在我们也可以在自己的string类中定义一个。

静态成员变量的声明和初始化！不可以直接给缺省值：static size_t npos = -1;因为静态成员变量是属于类的！缺省值给的是初始化列表，静态成员不会通过初始化列表初始化！

有个奇怪的C++语法：const static size_t npos = -1;是能够编译通过的！只不过这个语法仅限于整形家族，是不是特别戳！

3：我们可以换一种移动字符的方式嘛，将end 初始化为 _size + n 然后将 end - n 的字符赋值给 end 也可以。这样就不会有特殊情况了！只不过代码有点奇怪！

我们选择第二种解决办法来实现我们的代码！
```
void insert(size_t pos, size_t n, char ch)
{
	assert(pos <= _size);
	if (_size + n > _capacity)
		reserve(_size + n);
 
	int end = _size;
	while (end >= pos && end != npos)
	{
		_str[end + n] = _str[end];
		end--;
	}
	for (int i = 0; i < n; i++)
		_str[pos++] = ch;
	_size += n;
}
```
11.2 void insert(size_t pos, const char* s)

有了前面插入n个字符的铺垫，这个函数就很好实现啦！

1：检查pos的合法性。

2：计算字符串常量的长度 len，判断len + _size 是否大于 _capacity，如果大于则需要扩容！

3：移动字符，移动的方法我们还是选择上面的第二种哈！

4：插入新的字符串！
```
void insert(size_t pos, const char* s)
{
	assert(pos <= _size);
	size_t len = strlen(s);
	if (len + _size > _capacity)
	{
		reserve(len + _size);
	}
	int end = _size;
	while (end >= pos && end != npos)
	{
		_str[end + len] = _str[end];
		end--;
	}
 
	for (int i = 0; i < len; i++)
	{
		_str[pos++] = s[i];
	}
 
	_size += len;
}
```
12. void erase(size_t pos, size_t len = npos)

这个函数就是删除pos位置后面的 len 个字符！

1：检查 pos 的合法性。

2：如果 len 不传或者 len 传得比较大！就是删除 pos 之后所有的字符！即，当 pos + len >= _size 的时候与不传 len 的时候是等效的！这个时候我们只需要将 pos 位置的字符修改为 '\0' 即可。然后更新 _size;

3：如果 len 比较小，那么我们就需要移动字符啦！

假设字符串是："abcdefg" 我们要删除 pos = 1 后面的 3 个字符。我们可以使用 for 循环，初始化循环变量为 i，然后将 i + len 的字符移动到 i 的位置。很明显循环结束的条件就是当 i > _size - len.

移动完成之后更新_size 就可以啦！
```
void erase(size_t pos, size_t len = npos)
{
	assert(pos < _size);
	if (len == npos || pos + len >= _size)
	{
		_str[pos] = '\0';
		_size = pos;
	}
	else
	{
		for (int i = pos; i <= _size - len; i++)
			_str[i] = _str[i + len];
 
		_size -= len;
	}
}
```
13. find()

find函数我们实现两个版本：1. 从 pos 位置开始查找字符。2. 从 pos 位置开始查找字符串。

13.1 size_t find(char ch, size_t pos = 0)

这个函数就很好实现啦。我们先检查一下pos，然后从pos位置开始查找string中有没有这个字符就行啦！找不到返回npos！
```
size_t find(char ch, size_t pos = 0)
{
	assert(pos < _size);
	for (int i = pos; i < _size; i++)
		if (_str[i] == ch)
			return i;
	return npos;
}
```
13.2 size_t find(const char* s, size_t pos = 0)

我们直接套用 C语言的库函数 strstr()，就可以了！注意参数的传入以及返回值的书写。strstr的原型：

我们要从 pos 位置开始找，因此参数1的实参应该怎么写：_str + pos。

strstr的返回值是一个char* 我们可以通过指针减指针来获得查找成功的下标！
```
size_t find(const char* s, size_t pos = 0)
{
	assert(pos < _size);
	const char* ptr = strstr(_str + pos, s);
	if (ptr)
	{
		return ptr - _str;
	}
	else
		return npos;
}
```
14. string substr(size_t pos = 0, size_t len = npos)

从pos位置截取 len 个字符来构造返回一个新的string对象。

1：检查pos合法性，pos >= _size 都是不合法的！

2：如果不传 len 或者说 pos + len > _size，就是截取 pos 之后的所有字符，此时我们可以修正截取的实际字符数量，令 n = _size - pos。

3：根据实际的字符数量，遍历字符构造字符串返回即可！我们可以在遍历的时候使用 +=。
```
string substr(size_t pos = 0, size_t len = npos)
{
	assert(pos < _size);
 
	size_t n = len; //实际截取的字符数量
	if (len == npos || pos + len > _size)
	{
		n = _size - pos;
	}
	string s;
	for (int i = 0; i < n; i++)
		s += _str[pos++];
	return s;
}
```
15. void resize(size_ t n, char ch = '\0')

这个函数的使用在 string 使用哪一节是讲过的了！

1：如果 n < _size 很简单，将_size位置的字符修改为 '\0' 即可！

2：如果 n >= _size，我们就需要考虑是否要扩容啦！如果 n > _capacity 需要扩容，否则不需要。因此，我们直接调用 reserve(n)，在 reserve 的实现中我们是判断了 n 是否大于 _capacity 的，因此不用担心！

3：用 ch 初始化新的空间即可！
```
void resize(size_t n, char ch = '\0')
{
	if (n < _size)
	{
		_str[_size] = '\0';
		_size = n;
	}
	else
	{
		reserve(n);
		for (int i = _size; i < n; i++)
			_str[i] = ch;
 
		_size = n;
		_str[_size] = '\0';
	}
}
```
16. void clear()

比较简单，我们只需要将下标为 0 的字符修改为：'\0'，将_size 更新为 0 即可！
```
void clear()
{
	_str[0] = '\0';
	_size = 0;
}
```
17. 比较运算符的重载

17.1 bool operator<(cons string& s) const

字符串的比较一直都是按照字典序来比较的哈！不是按长度哦！

当 memcmp 的结果不等于0 的时候，如果结果 < 0，则返回 true；如果结果 > 0 返回false。

我们来看memcmp == 0的情况：

1：hello && helloXX，这种情况我们用 memcmp 比较，比较的字节数为两个string 对象中 size()较小的string中有效字符个数所占的字节数。memcmp 的结果为 0，但是因为 helloXX 的hello 后面还有字符，因此 hello < helloXX，返回true。

2：aaaXX && aaa，同样选择用 memcmp 比较size较小的string的字节数，结果依然是 0，但是因为 aaaXX 的 aaa 后面还有字符，因此 aaaXX > aaa，返回false。

3：hello && hello，这种情况 memcmp 的结果依然是 0 ，但是两个string 后面肚饿没有字符，因此 hello == hello，返回false。

所以，在 memcmp == 0的情况下，如果 _size < s._size，那么返回 true 否则返回 false。

这里你可能发问了，为什么不能用 strcmp 呢？原因就是可能出现这样的字符串：

aaa\0bbb && aaa\0ccc，strcpy的结果是0，两个string 对象的size也相等，用strcmp得到的结果就是 false，但起始结果是 true。
```
bool operator<(const string& s) const
{
	int ret = memcmp(_str, s._str, _size < s._size ? _size : s._size);
	return ret == 0 ? _size < s._size : ret < 0;
}
```
17.2 bool operator==(cons string& s) const

两个string相等的前提条件就是他俩的size必须一样，因此如果 size 一样再 memcmp 就行啦！
```
bool operator==(const string& s) const
{
	return _size == s._size && memcpy(_str, s._str, _size);
}
```
17.3 接下来全部都是复用啦
```
bool operator<=(const string& s) const
{
	return (*this) < s || (*this) == s;
}
 
bool operator>(const string& s) const
{
	return !((*this) <= s);
}
 
bool operator>=(const string& s) const
{
	return !((*this) < s);
}
 
bool operator!=(const string& s) const
{
	return !((*this) == s);
}
```
18. ostream& operator<<(ostream& out, const string& s)

库里面的 string 是支持 cout << s << endl的。就是因为实现了流插入运算符的重载！在C++中，ostream的实现是禁用了拷贝构造函数的，因此形参只能写 ostream 的引用。

还有就是重载流插入和流提取的时候都不要写成成员函数，如果写成成员函数，使用operator<<的顺序就不符合我们的书写习惯啦！一定要写在你定义的namespace内部，不写在你定义的namespace内部函数形参这么写也行：

ostream& operator<<(ostream& out, const Tchey::string& s)

因为可能存在 "aaaa\0bbbb" 这样的神奇字符串，因此我们的函数体不能直接写成：

out << s.c_str();
```
ostream& operator<<(ostream& out, const string& s)
{
	for(int i = 0; i < s.size(); i++)
		out << s[i];
	return out;
}
```
19. istream& operator>>(istream& in, string& s)

这里的函数体千万不敢这样写：

in >> s.c_str();

第一：直接这样写并没有为 s 开辟空间，强行写入会引起内存错误，单只程序崩溃的！
第二：就算你提前开辟了空间，但是我们并不知道用户要输入多少字符哇，提前开多少空间呢？

因此，我们是不能直接这么搞的，需要一个字符一个字符得读！

我们定义一个char 变量 ch 用于接收输入的字符，每输入一个字符我们就让 s += ch，直到 ch == ' ', 或者 ch == ‘\0’ 的时候，结束输入(循环)。

但是这里有一个魔鬼细节，如果用 cin 输入的话，是无法读入空格和换行的导致死循环，这个可以你自己在编译器上验证，编译器认为空格和换行是用来区分不同的变量的输入的，因此 cin 读不进去空格和换行。我们可以用 cin.get() 这样就能读取到空格和换行啦。

于是我们写出了这样的代码：

没问题了吗？并不是！当我们尝试向一个string对象进行连续的 cin 时，它还是会保留上一次的输入，因此在输入之前还需要清楚 s 原有的字符！

还不够，我们对比 std::string 发现，输入一连串空格之后再输入其他字符，或者输入一连串换行之后再输入其它字符，是能够正确跳过空格和换行输入有效字符的，因此我们还需要清空缓冲区！
```
istream& operator>>(istream& in, string& s)
{
	//清除s的其他字符
	s.clear();
 
	char ch = in.get();
 
	//清空缓冲区
	while (ch == ' ' || ch == '\n')
		ch = in.get();
 
	while (ch != ' ' && ch != '\n')
	{
		s += ch;
		ch = in.get();
	}
	return in;
}
```
还有一些人认为，如果输入的字符数量很多，可能会导致 s 扩容次数太多，影响效率。因此搞出了一个数组，用来暂时存放输入的字符，等到这个字符满了，或者输入结束，再让 s += 这个字符数组。
```
istream& operator>>(istream& in, string& s)
{
//清除s的其他字符
s.clear();
 
char ch = in.get();
 
//清空缓冲区
while (ch == ' ' || ch == '\n')
	ch = in.get();
 
char buff[128];
int index = 0;
 
while (ch != ' ' && ch != '\n')
{
	if (index == 127)
	{
		buff[127] = '\0';
		s += buff;
		index = 0;
	}
	buff[index] = ch;
	ch = in.get();
}
 
if (index != 0)
{
	buff[index] = '\0';
	s += buff;
 
}
 
return in;
}
```
20. 拷贝构造函数

哈哈，你肯定想知道为啥拷贝构造函数现在才写！肯定不是因为忘了！哈哈哈！

string 类中的对象维护了堆区的数据，因此我们要实现深拷贝！深拷贝之前就讲了很多啦！不再赘述！

20.1 传统写法
```
string(const string& s)
{
	char* tmp = new char[s._capacity + 1];
	memcpy(tmp, s._str, s._size + 1); //+1 是为了拷贝\0
	delete _str;
	_str = tmp;
	_size = s._size;
	_capacity = s._capacity;
}
```
20.2 现代写法

现代写法之所以现代就是因为它现代！
```
string(const string& s)
{
	if(this != &s)
	{
		string tmp(s.c_str());
		std::swap(_str, tmp._str);
		std::swap(_size, tmp._size);
		std::swap(_capacity, tmp._capacity);
	}
}
```
我们通过 s.c_str() 构造出来一个 tmp 对象，然后通过 swap 函数将 tmp 维护的空间和信息交给 *this 对象。又因为 tmp 是一个临时对象，出了作用域 tmp 就会销毁，调用析构函数，正好将 *this 维护的空间释放掉，简直就是依据两得！有点工具人的味道，哈哈哈！

21. void swap(string& s)

这个函数就是用来交换两个对象所维护的空间和信息的，实现这个函数我们能更加方便的使用现代写法！
```
void swap(string& s)
{
	std::swap(_str, s._str);
	std::swap(_size, s._size);
	std::swap(_capacity, s._capacity);
}
```
22. 赋值运算符重载

有了现代写法，赋值运算符重载写起来那简直叫一个爽！
```
//传统写法
string& operator=(const string& s)
{
	if (this != &s)
	{
		char* tmp = new char[s._capacity + 1];
		memcpy(tmp, s._str, s._size+1);
		delete[] _str;
		_str = tmp;
 
		_size = s._size;
		_capacity = s._capacity;
	}
 
	return *this;
}
 
 
//现代写法
string& operator=(string tmp)
{
	swap(tmp);
 
	return *this;
}
```
23. string迭代器的实现

迭代器在string中就是 char* 的指针，迭代器究竟是什么，等我们学到 list 再来理解！

首先我们要在 string 中定义一个迭代器类型！

然后我们就逐一来实现 begin() 和end() 起始很简单啊！

begin()：返回下标为 0 的元素的地址。

end()：返回 _size 下标处的地址。

*，++，--，都不需要自己实现，因为指针是内置类型，并且 string 的物理空间连续。完全不需要自己动手！

注意实现两个版本：const 和非 const 版本！

迭代器只要实现了，范围 for 就可以使用了，如果范围 for 不知道是什么的老铁可以复习一下：

21天学会C++：Day8----范围for与nullptr_姬如祎的博客-CSDN博客

范围for的底层就是迭代器，范围for会被无脑替换成迭代器遍历！
```
iterator begin()
{
	return _str;
}
 
iterator end()
{
	return _str + _size;
}
 
const_iterator begin() const
{
	return _str;
}
 
const_iterator end() const
{
	return _str + _size;
}
```
到这里，我们就实现了一个属于自己的string，模拟 std::string 实现的方法有很多。模拟只是为了加深对 string 的理解与应用！好啦！不见不散！
相关阅读:
NFT: 开启加密艺术时代的无限可能
 Codeanalysis（tca）后端二次开发环境搭建
 Mediapipe Android环境搭建
 十大服装店收银系统有哪些好用的服装收银软件推荐
 qt连接MySql数据库及增删改查示例
 科比，老大1000天
 项目管理，看这篇就够了，但一定要实操！
ORB-SLAM3在保存地图时高频率崩溃问题
 头一次见单例模式讲的如此透彻
 嵌入式 Linux 入门（九、Linux 下的磁盘管理）
原文地址：https://blog.csdn.net/m0_73096566/article/details/133932980

1. string类的成员变量

2. 构造函数

3. 析构函数

4. const char* c_str() const

5. size_t size() const

6. char& operator[](size_t pos)

7. void reserve(size_ t n)

8. void push_back(char ch)

9. void append(const char* s)

10. operator+=

10.1 string& operator+=(char ch)

10.2 string& operator+=(const char* s)

11. insert()

11.1 void insert(size_t pos, size_t n, char ch)

11.2 void insert(size_t pos, const char* s)

12. void erase(size_t pos, size_t len = npos)

13. find()

13.1 size_t find(char ch, size_t pos = 0)

13.2 size_t find(const char* s, size_t pos = 0)

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

15. void resize(size_ t n, char ch = '\0')

16. void clear()

17. 比较运算符的重载

17.1 bool operator<(cons string& s) const

17.2 bool operator==(cons string& s) const

17.3 接下来全部都是复用啦

18. ostream& operator<<(ostream& out, const string& s)

19. istream& operator>>(istream& in, string& s)

20. 拷贝构造函数

20.1 传统写法

20.2 现代写法

21. void swap(string& s)

22. 赋值运算符重载

23. string迭代器的实现