【C++】深入浅出STL之string类

文章篇幅较长，越7万余字，建议电脑端访问

一、前言

本文我们就要来说一说STL中的string类，这也是我们在写C++代码的时候使用最多的

1、C语言中的字符串

首先要来谈的一点就是为什么要学习string类

• string意为字符串，那回忆一下我们在C语言阶段所学习的字符串，是以'\0'结尾的一些字符的集合，为了操作方便，C标准库中提供了一些str系列的库函数，如果忘记了就再看看 字符串操作函数
• 但是这些库函数与字符串是分离开的，不太符合 OOP 的思想，而且底层空间需要用户自己管理，稍不留神可能还会越界访问

因此，在C++中专门搞出了一个与字符串相关的类，我们知道C++是面向对象的，我们可以在类内去写各种成员函数来对外提供操作字符串的接口，这个类就是string类

2、string类的使用场景

那这个string有什么实际的应用场景呢，这可多了去了，如果经常刷题的同学应该瞬间能反应过来

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

字符串转整形数字

字符串相加

二、初步认识string类

1、概述

string类的文档介绍

• 我们来到string类的文档中可以看到它确实是一个类，而且是由一个模版类basic_string所实例化出来的

• 如果你有学习过 C++模版 的话就可以知道这个类即为【类模版】

• 然后由这个类模版就实例化出了很多的模版类，其中就包含我们本文所要学习的string类

那有同学问，下面的这几个【wstring】、【u16string】、【u32string】是什么呢？

• 这一块的话要涉及到编码相关的知识，如果读者对这一块没什么接触的话就当了解一下

对于编码而言我们谈到最多的就是 ASCLL码 ，它的全称叫做【美国信息交换标准代码】，总共包含了像大小写的中英字母、数字、标点符号等等共128个，用来表示老美的的一些文章字符完全足够了。

而对于ASCLL码来说，是存在一个东西叫做映射表，即一个ASCLL码值就对应一个字符

我们可以到VS中来观察一下，其实在内存中所存放的都是ASCLL码，只不过呢在显示的时候却转换为了表中所对应的字符。这个63 64 65 66其实是十六进制的写法，转换为十进制即为97 98 99 100，那它们所对应的字符即为a b c d

如果有同学还是不相信的话可以看看下面这个，我给str[0]这个位置放了数值为97，但是呢其为一个string类的对象，所以里面所存放的都是字符，可以看到在打印出来后的结果就是97所对应的ASCLL码值a

但是呢对于我们的一些中文汉字却是远远不够的，例如说下面这个”比特”，我通过【sizeof】打印出了其在内存中所占字节数，发现有5B，这是为什么呢？原因就在于汉字的存储规则不是按照ASCLL码来的，而是专属于我国的一套编码字符集叫做GBK。在【GB2312-80】中就存储了很多有关汉字的规则

一般来说一个汉字对应的2个字节，这里的”比特”是因为最后还有一个\0

最后对这个string类的特性做一个总结：

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

⚠ 在使用string类时，必须包含#include头文件以及using namespace std

2、常用接口细述

对string类大体有个了解后我们就要去学着使用这个类里面的一些函数了

1）string类对象的默认成员函数

① 构造函数

• 点进第一个成员函数Constructor就可以看到存在7个重载，其中我框出来的三个是重点，要着重记忆，其余的了解一下即可

• 我将上面的函数整理了一下，方便观看

string();		// 构造一个空字符串
string (const char* s);				// 用C-string来构造string类对象
string (const char* s, size_t n);	// 用C-string的前n个字符来构造string类对象
string (size_t n, char c);		// 生成n个c字符的字符串

string (const string& str);		// 利用原先的字符串做拷贝构造
// 拷贝str字符串中从pos位置开始的len个字符
string (const string& str, size_t pos, size_t len = npos);	

• 然后我们到VS里演示一下

• 前面的几个都好理解，来讲一下最后的这一个，可以看到在函数形参这一块给出了一个缺省值叫做npos，可能有的同学不清楚这个npos是什么东西

// 拷贝str字符串中从pos位置开始的len个字符
string (const string& str, size_t pos, size_t len = npos);	

• 这个我们也可以到文档中来查看一下，发现它是【无符号整数的最大值】

• 那这个值究竟是多少呢，我们可以将其打印出来看看

• 也可以到Linux平台下来查看发现不太一样，因为在Linux下使用的是g++编译器，它们底层所定义的规范是不一样的

💬 但是呢，无论这个数值是多少，其实影响都不大，因为我要说明的是即便我们不给出这个参数的话，编译器默认就是从当前的这个【pos】位置开始一直到字符串末尾

• 继续通过文档来观察一下，substring指的就是子串的意思，意思即为 从pos位置的len个长度去拷贝字符串的一部分(如果str字符串太短或者len为npos则直接到达字符串的末尾)

那现在的话你应该可以明白最后的这个参数我为何没有传递却拷贝到了后面的所有字符

• 接下去呢我们来讲一下赋值重载，这个我们在讲 类的六大成员函数 有提到过这个，它只能出现在类内但是不可以出现在类外，否则会产生一个冲突

赋值重载

string& operator= (const string& str);	// 将一个string对象赋值给到另一个
string& operator= (const char* s);		// 将一个字符串赋值给到string对象
string& operator= (char c);				// 将一个字符赋值给到string对象

• 同样，我们到VS中来做一个测试，可以看到这三种方式都可以构成一个string的对象，不过照这么来看后面的这两种似乎没多大用处，用的最多的还是第一种

2）string类对象的常见容量操作

接下去我们来讲一讲有关string类中有关容量的一些操作

① size、length、capacity

• 首先要来讲的是【size】和【capacity】，这其实就和我们在顺序表中所介绍的意思差不多，前者表示当前字符串已经存放了多少数据，后者表示当前这个字符串可容纳的空间数
• 我们到VS下通过调试来观察一下，可以看到现在这个str没有任何的数据，而VS为我们开出了大小默认为15的空间，其实这里应该是16，只不过最后的\0也占了一个大小

• 然后去构建出一个具体的字符串来进行观察，发现size的值发生了一个变化。不仅如此，我还打印了一下这个字符串的length属性，观察到其和size是一样的

• 然后我们点进到这两个函数的定义中可以发现它们的定义竟然是一样的

• 我们在文档的时候，一定会有一种很奇怪的感觉，在C++的容器里面为什么没有string呢？这里要追溯到STL的一个诞生历史，其实对于string这个类，是不属于STL的，因为它是在STL之前就已经存在了的，属于C++标准库里的内容

• 像下面这样来看的话，STL是属于标准库中的一部分，string也是属于标准库的一部分，但是呢二者却没有什么直接的关联。在最早期string的长度接口是定义为【length】的，到后面STL出了之后才改为了【size】，但是这一块我们需要去考虑到一个历史追溯的问题，所以不能将这个接口给删除，因而我们才看到一模一样的两个接口实现

💬 后续我们在使用到时候直接用【size】即可，因为其他STL库中的接口使用的也是【size】

追究完这个【size】之后，我们再来谈谈这个【capacity】

• 我们使用的是下面这段代码进行测试

void TestCapacity()
{
	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';
		}
	}
}

• 以下分别是在Windows和Linux平台下的运行结果，通过不断往这个s中添加字符来扩充他的容量

💬 可以看到Windows下的VS中，扩容的大小是呈现一个1.5倍大小的趋势；可是在Linux平台下呈现的却是2倍大小的趋势

• 这其实就是因为不同平台下这个STL库的内部实现是不一样的，甚至都是在VS中，不过呢使用不同版本的VS其大小也是不一样的

② maxsize

接下去呢我们再来说说这个【maxsize】

void TestMaxsize()
{
	string s("hello");
	cout << s.size() << endl;
	cout << s.max_size() << endl;
}

• 一样，我们放在这个双平台下演示一下，发现结果也是各不相同

③ clear

接下去呢，我们来讲【clear】

void TestClear()
{
	string s("hello");
	cout << "size: " << s.size() << endl;
	cout << "capacity: " << s.capacity() << endl;

	s.clear();
	cout << "size: " << s.size() << endl;
	cout << "capacity: " << s.capacity() << endl;
}

• 这次双平台下演示的结果就一样了，并没有什么差异，对于clear来说，它只会清空字符串中的【size】，但对于【capacity】来说是不会有什么变化的，如果你是这个接口的实现者一定不会去清空这个【capacity】容量的大小，万一后面又需要插入字符呢？此时又需要去进行一个扩容，是非常麻烦的

④ empty

• 接下去再来看看【empty】这个接口，很简单，我们复用一下上面这段代码，看一下这个字符串在清空前后的【empty】结果即可，于是就可以看到没被清空的时候返回0，代表false不空，而被清空之后返回1，代表true为空

⑤ reserve

接下去呢我们来讲讲这个【reserve】，可以提前为一个字符串开出指定的空间

• 这一块我们可以放在之前观察【capacity】的地方进行测试，可以发现在开出预留空间后就不会去执行下面的这一段扩容逻辑了，因为此时空间已经够了

• 可以看到我们在VS下给定预留空间为100的时候此时系统给我们的大小为【111】，很明显是要多出一点的，但是在Linux下去运行的话就不是这样了，而是给多少开多少，就给了我们【100】的空间

💬 那有同学问：这是为什么呢？

• 原因也是一样，平台不同实现不同，所以两个平台都会去做一个演示

可能上面这样还不是很好理解，我们举个例子来理解一下

• 这个月呢你想买件衣服，但是没有零花钱了，于是就是找妈妈要零花钱，总共要个100块，那你妈妈觉得既然衣服都买了的话，裤子也一起买吧，于是直接给你打了200块
• 此时这种行为就和VS下是一样的，虽然你只是要了100空间的大小，但是呢编译器却给了你111

• 那像Linux里这种行为就是你要多少钱你妈妈就给你打多少，一分不多、一分不少，要开100个容量大空间就给你100

我们也可以到文档中来看看

• 说如果参数中这个【n】比当前容量的大小来得大的话，那么会增长到n个字符的空间大小

不过呢这个文档下面还有一部分，那就是不仅会发生【增容】的情况，也会发生【减容】的情况

• 我们可以在最后的地方加上s.reserve(10)来试试是否可以，却发生容量没有发生变化

• 但是呢，当我到Linux平台下再来演示的时候，却发现有了不一样的变化，确实发生了【减容】的情况
• 其实在这里就对应了文档中所说的【non-binding】，即不可控的

可是，我接下来的操作，可能就会让你惊掉下巴(⊙ˍ⊙)

• 可以看到我在即将【减容】前使用了clear将字符串中的数据清空后，此时再去使用reserve的时候容量就发生了变化，回到了最初的那个默认大小

• 那到Linux下来看看发现也会其作用，不过是缩容到指定的大小，而不是默认的大小

• 再reserve(0)一下看看果然也是这样

从以上的种种结果来看可谓真的是【变化多端】鸭🦆，多然是不好掌控

⑥ resize

void resize (size_t n);
void resize (size_t n, char c);		// 初始化数据为n个c字符

• 讲完【reserve】后，我们再来讲讲【resize】，它们很类似，但也有不同之处

void TestResize()
{
	string s("abcdef");

	// 开空间
	s.reserve(100);
	cout << s.size() << endl;
	cout << s.capacity() << endl;
	cout << "---------------------" << endl;

	// 开空间 + 填值初始化
	s.resize(200);
	cout << s.size() << endl;
	cout << s.capacity() << endl;
}

• 通过对它们两个做一个对比可以发现对于【reserve】而言仅仅只是对capacity起作用，size就是初始化的字符串个数；
• 但是对于【resize】而言size和capacity会一起发生改变，前者变为传递的参数n，后者则遵循VS下的扩容规则，比给出的参数多一些

一样，我们通过解读文档的形式来看看这个函数还有哪些内容

1. 如果 n > 当前的字符串长度，则在末尾插入所需数量的字符以达到n的大小来扩展当前内容
2. 如果n < 当前的字符串长度，则会去进行一个删除的操作，删除第n个字符之后的字符

第一点我们刚才已经验证过了，接下去我们再来试试第二点，看看是否真会去做一个删除的操作

• 可以看到，若是传递了 < n的参数进去的话，再去打印这个字符串就会发生一个截断的现象

上面我们所使用的都是第一个只传递n，不过下面还有一个重载形式可以【初始化数据为n个c字符】，看到最后这里也有说到如果这个c是特殊的话，就会去以这个c字符去填充后面多开空间的部分

• 可以看到若是我们没有去制定后面这个字符c的话，默认会以'\0'进行填充的，那如果我们制定出字符呢？

• 此时我指定了后面的字符c，此刻后面填充的就是我们所指定的那个字符

s.resize(100, 'a');

⑦ shrink_to_fit

• 最后我们再来讲一个，它也可以做到一个减容的效果

void shrink_to_fit();

• 立马我们就来试一试它究竟能起到什么样的效果，发现在使用后可以让原本在【resize】之后不符合大小的capacity变得适应size的大小， 确实也有一些作用，不过使用的场景不多，读者了解一下即可

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

① operator[]

	  char& operator[] (size_t pos);
const char& operator[] (size_t pos) const;

首先我们来说说这个operator[]，相信学习过 类和对象的运算符重载 的同学一定不陌生

• 之前我们都是像下面这样去访问string字符串的，那现在有了这个operator[]，我们就可以使用【下标 + [ ]】的形式去访问字符串中的每一个元素

void TestOperator()
{
	string s("abcdef");

	cout << s << endl;
}

• 那就是像下面这样去做一个访问即可，要使用到的是我们前面所学的【size】这个接口，获取到字符串的大小

for (int i = 0; i < s.size(); i++)
{
	cout << s[i] << " ";
}

我们知道，其实这个string类的对象会在堆区中开辟出一块数组空间来存放相对应的字符，最后为了和C语言保持一致会在最后面加上一个\0，那为何这里在打印的时候没有看到呢？

• 通过调试来进行观察，我们可以发现其在遍历的过程中并没有遇到\0，这是为何呢？

• 这其实是因为string的封装得过多了，因此我们在进行观看的时候需要一直点到最里面才可以，继而发现了我们的\0

• 那既然我们可以通过【下标 + [ ]】的形式去访问字符串中的每一个元素，那在访问的同时是否可以进行修改呢？这当然是可以的，马上来试试👇

for (int i = 0; i < s.size(); i++)
{
	s[i]++;
}

• 打印一下可以看到，每个元素 + 1之后再去遍历打印的时候就有了不同的结果

• 不仅如此，我们还可以单独使用，将每个元素++之后我们再把s[0]--，那么在打印的时候看到的结果即为[a]

从上面的种种我们可以看到这个operator[]使得字符串可以让我们像数组一样去使用，做增、删、查、改很方便

• 但是呢，上面这种string[]的形式和下面这样对字符数组的访问是有本质区别的

string s("abcdef");
char s2[] = "hello world";
s[1]++;		// -> operator[](1)++
s2[1]++;	// -> *(s2 + 1)++

• 这一块我们可以通过汇编来进行查看，发现s[1]++在底层是转换为operator[]的形式；但是对于s[2]++却是在做一些解引用的操作，这一块看不懂也没关系，但在学习了C语言操作符后我们要知道对于[]来说其实就是一种解引用的形式

【温馨提示】：只能用于string + vector + deque，但是链表、树不能用，链表各个结点的空间不连续

• 对于【vector】和【deque】，我在后续都会讲解到，它们都是STL中的容器，而且在内存中与string一样都是连续的，因此我们可以像访问数组一样去访问里面的元素。但是呢，像【链表】、【树】这样的结果，它们的一个个结点在空间中都是都是离散的，无法做到像数组那样去连续访问

② at

当然，除了下标 + []的形式，我们还可以通过【at】的形式去做一个访问

• 一样通过查看文档来观测一下，也是具有两个重载，一个是普通对象，一个则是const对象

void TestAt()
{
	string str("abcdef");
	for (int i = 0; i < str.size(); i++)
	{
		cout << str.at(i) << " ";
	}
	cout << endl;
}

• 可以看到可以在边遍历的时候边修改字符串中的值

我们再来看看这个const对象

const char& at (size_t pos) const;

void func(const string& s)
{
	for (int i = 0; i < s.size(); i++)
	{
		s.at(i)++;
		cout << s.at(i) << " ";
	}
}

• 可以观察到，此时我们再去修改这个字符串中的内容时就会出问题了，原因就在于这个对象s具有常性，是无法修改的

对于oparator[]和at()来所，还要再做一个对比，即它们在处理异常这一块

可以看到对于上面的oparator[]来说若是产生了一个越界访问的话就直接报出【断言错误】了

然后看到对于at()来说虽然也是弹出了警告框，但是呢这个叫做【抛异常】，之后我们在学习C++异常的时候会讲到的

• 此时我们应该再去仔细地看一看文档，里面说到在检查出所传入的pos位置有问题时，就会报出out_of_range的异常，这也就印证了上面的现象

• 那对于异常而言都是可以去捕获的，那就是采用try...catch的形式。此时我们再运行的话就可以发现此异常被捕获了，而且打印出了异常的信息

③ 迭代器

那接下去呢，我就要来讲讲【迭代器】了，它是我们在学习STL的过程中很重要的一部分内容，让我们对容器的理解能够更上一层楼

• 在这之前呢，我们认识两个最常见的接口函数，即为begin和end
  • begin获取一个字符的迭代器
  • end获取最后一个字符下一个位置的迭代器

• 迭代器是是另一种访问string中内容的方式，图示如下，我们使用一个it去保存这个字符串【begin】处的位置，那么在其不断进行后移的过程中，就是在遍历这个字符串，当其到达最后的【end】处时，也就遍历完了，此刻便会停了下来

• 好，我们一起来看看这段代码

void TestIterator()
{
	string s("abcdef");

	string::iterator it = s.begin();
	while (it != s.end())
	{
		cout << *it << " ";
		it++;
	}
	cout << endl;
}

• 除此之外，迭代器也可以像数组那样在遍历的时候修改内部的元素，it取到的是每个元素的位置，那么对于*it来说即为每个元素

string::iterator it = s.begin();
while (it != s.end())
{
	(*it)++;
	it++;
}

• 来观察下运行结果就发生也没问题，可以进行修改

• 因此我们看迭代器的这种方式，其实和指针非常得类似，不过呢不能完全这样说，所以你可以说 iterator是像指针一样的类型，有可能是指针，有可能不是指针

这边再拓展一点，上面说到迭代器在我们学习STL的过程中起着很大的作用，原因就在于其他的容器都可以使用这种形式来进行遍历

void TestIterator2()
{
	vector<int> v;
	v.push_back(1);
	v.push_back(2);
	v.push_back(3);
	v.push_back(4);

	vector<int>::iterator vit = v.begin();
	while (vit != v.end())
	{
		cout << *vit << " ";
		vit++;
	}
}

• 可以看到，对于vector容器来说，也是可以使用迭代器去做一个遍历的

• 不仅如此list也是可以使用迭代器来进行访问的

💬 好，上面仅仅作为拓展，如果读者不懂得话也没关系，下一文就会学习到

【小结】：

好，对上面的内容做一个小结。iterator提供一种统一的方式访问和修改容器

还记得我们在初步认识STL的时候讲到的STL的六大组件，除了【容器】之外最重要的就是【算法】，这里我先简单地介绍几个算法并演示一下

• 首先就是我们使用到最多的【reverse】函数，字面意思：颠倒元素

• 观察其参数我们可以发现，传入两个迭代器即可，那刚好就是我们前面所学的【begin】和【end】

reverse(s.begin(), s.end());

• 一起来看一下结果就可以发现确实string字符串内的字符都发生了一个翻转，但是有一个头文件#include <algorithm>可不要忘记了哦

• 同样，对于vector容器来说也是同样适用

• 好，再来说一个【sort】，也很明了，就是对区间内的元素去做一个排序的操作，此时我们可以看到两个重载形式，第一个就是正常传入区间迭代器，而第二个重载形式则是可以传递【仿函数】，它也是STL的六大组件之一，我们在后续也会进行学习，这里先提一句
• 如果你有看过 C语言回调函数 的话就可以很清晰地看出来是它们很类似，这里不做展开

• 立马，我们来看看如何去进行使用，也是传递【begin】和【end】即可

sort(s.begin(), s.end());

• 通过运行结果我们可以看到再 通过sort进行排序后原本的乱串变成了有序串

💬 其余容器的这里就不演示了，读者可自己下去试试看，总结一下：算法可以通过迭代器去处理容器中的数据

好，讲完正向迭代器，我们再来说说【反向迭代器】

• 首先我们要来了解一下新的两个接口【rbegin】和【rend】

• 还是结合具体图示来观察一下，对于【rbegin】来说指向的是最后一个字符的位置，对于【rend】来说它指向的是第一个字符的前一个位置，

• 好，我们来看一下具体该如何去使用，其实和 正向遍历 非常相似，只是这个迭代器我们要换一下，通过它们二者的返回值其实就可以看得出出来

reverse_iterator rbegin();
reverse_iterator rend();

展示一下代码

string::reverse_iterator rit = s.rbegin();
while (rit != s.rend())
{
	cout << *rit << " ";
	rit++;
}

再来看看结果

好，讲完了正向和反向迭代器后，我们再来拓展地讲一些东西

• 仔细地观察一下这四个接口函数，发现除了 iterator 和 reverse_iterator 之外，还有const_iterator 和 const_reverse_iterator，那后面的这两个我们要如何去使用呢？

• 我们这里将迭代器遍历封装为函数，采取引用传值减少拷贝构造，那还需要加上const做修饰防止权限放大

void Func(const string& s)
{
	string::iterator it = s.begin();
	while (it != s.end())
	{
		cout << *it << " ";
		it++;
	}
}

• 但是呢当我在编译之后却发现出了问题，说是无法去进行一个转换

• 那我们用用上面看到的两个新的迭代器试试，发现确实不会有问题了，原因就是在于对象s是属于const对象，那么它在调用【begin】的时候返回的就是const迭代器，是【只读】那此时我们若是使用普通迭代去接收的话就是【可读可写】，也算是一个权限放大的问题

• 我们再来试试反向迭代器，可以发现也是具有同样的问题

• 此时只有将迭代器换成const_reverse_iterator才可以，但你是否觉得这样写过于复杂了呢？

string::const_reverse_iterator rit = s.rbegin();

• 如果有同学了解C++11的关键字auto的话就可以清楚其可以完成自动类型转换的功能，不需要我们去关心具体的类型，这个关键字我在下面讲到【范围for】的时候还会再提到的，读者可以自行先了解一下

auto rit = s.rbegin();

• 那么这个迭代器是否真的能做到【只读】呢，我们去修改一下即可，发现确实是呈现一种只读的效果

【总结】：

• 好，最后来总结一下我们上面所学习的四种迭代器，分别是
  

④ 范围for

好，我花了很大的篇幅在介绍迭代器之后，我们再来讲讲范围for，这个是C++11才出来的，现在被广泛地使用

• 很简单，我们马上来看看具体的代码，它就是一种语法糖的，这里的auto就是我们上面所说到过的【自动类型推导】，那这里如果我们不用auto的话直接使用char也是可以的

void TestRangeFor()
{
	string s("abcdef");

	for (auto ch : s)
	{
		cout << ch << " ";
	}
	cout << endl;
}

• 来讲讲它的原理，通过汇编我们可以看到，范围for的底层实现还是【迭代器】，所以我们可以说在它在遍历的时候相当于是将*it的数据给到当前的ch，和迭代器的本质还是类似的

• 那这个范围for既然的底层实现既然都是迭代器的话，是否也可以像迭代器那样在遍历的时候去做一个修改呢？这当然是可以的喽~
• 但是呢，下面这样就不可以啦，因为这样的话ch在遍历的时候每次只会是当前字符的一份拷贝，那么在循环遍历结束后ch每一次的变化是不会导致字符串s发生变化的

• 那我们只需要让ch和字符串每一个字符所属同一块空间即可，那这个时候就使用我们所学习的【引用】即可

【注意事项】：

• 好，接下去我们几个注意事项

一个类如果不支持迭代器就不支持范围for，因为范围for的底层使用的也是迭代器

• 不是所有的类都支持迭代器的，例如我们之后要学习的stack类，它就是不支持的

• 可以看到，不支持迭代器，也是不支持范围for的

只能正着遍历，但是不能倒着

• 不仅如此，范围for也是不支持像迭代器那样倒着遍历的，这个无法演示，读者可以自行思考一下🤔

⑤ front 和 back

然后再来拓展两个C++11中新接口，看这个字面其实就可以看出【front】取到的是字符串的首字符，而【back】取到的则是字符串的尾字符

void TestBackAndFront()
{
	string str("abcdef");

	cout << str.front() << " " << str.back() << endl;
}

• 可以看到，确实取到了字符【a】和字符【f】

4）string类对象的修改操作

接下去呢我们来讲讲string类对象的修改操作

① push_back

• 很简单，就是往当前的字符串后面追加一个字符

• 但是要注意，push_back()仅能尾插一个字符，其他都是不可以的

② append

接下去呢我们再来讲讲【append】这个接口，它在string类中用的还是蛮多的

• 通过查看文档可以看到其重载的函数还是比较多的

string& append (const string& str);		// 追加一个string对象
// 追加一个string对象中的指定字符串长度
string& append (const string& str, size_t subpos, size_t sublen);	

string& append (const char* s);				// 追加一个字符串
string& append (const char* s, size_t n);	// 追加字符串中的前n个字符串
string& append (size_t n, char c);			// 追加n个字符

string s2("bbbbb");
s1.append(s2);
cout << s1 << endl;
s1.append(" ");

s1.append("ccccc");
cout << s1 << endl;
s1.append(" ");

s1.append("hello", 3);
cout << s1 << endl;
s1.append(" ");

s1.append(10, 'e');
cout << s1 << endl;

以下是测试结果，读者可以自行对照

③ operator+=(string)

对于上面的这两种调用函数的方式，你是否觉得过于麻烦呢？

• 接下去我介绍一种更加简便的字符串拼接操作，那就是+=，这个我们在讲 运算符重载 的时候有提到过。它一共有三个重载形式，分别是拼接一个string类的对象、一个字符串、一个字符

分别来演示一下

• 首先是两个string对象的拼接

name1 += name2;

• 然后呢是拼接一个字符串

name1 += "feng";

• 最后呢则是拼接一个字符

name1 += 'g';

💬 可以看出这个 += 确实是非常地方便，有了它你完全就懒得去用另外的【push_back】、【append】，当然它没有这二者的重载形式这么多，还是要以具体的情景为主

④ insert

然后呢我们再来看看【insert】这个函数，重载形式也蛮多的

// 在指定位置插入一个string对象
string& insert (size_t pos, const string& str);
// 在指定位置插入一个string对象里的一部分
string& insert (size_t pos, const string& str, size_t subpos, size_t sublen);
// 在指定位置插入一个字符串
string& insert (size_t pos, const char* s);
// 在指定位置插入一个字符串的前n个字符
string& insert (size_t pos, const char* s, size_t n);
// 在指定位置插入n个字符
string& insert (size_t pos, size_t n, char c);
// 在指定迭代器的位置插入n个字符
void insert (iterator p, size_t n, char c);
// 在指定迭代器的位置插入一个字符，并且返回一个迭代器的位置
iterator insert (iterator p, char c);

• 首先是第一个，在s的第0个位置插入了一个string的对象

• 然后是第二个，比较复杂一些。下面代表的是我们在当前字符串s的第6个位置插入字符串s3从第0个位置开始长度的6个字符

• 接下去是第三个，我们在string对象s的第三个位置处插入一个字符串“bbb”，运行起来就看到确实插进去了

• 那我们也可以指定插入一个字符串中的前n个字符

• 然后的话是在第5个位置插入2个字符d

• 学习过迭代器后再来看下面这个应该是没什么问题了，就是在起始位置插入指定的字符个数

• 接下去最后一个呢，则是在指定迭代器的位置插入一个字符，然后范围该位置的迭代器。看到我从这个地方开始向后遍历，打印了一下这个string对象

如果读者有看过 C语言版数据结构 的话就可以知道对于上面这些操作来说其底层实现都是需要挪动很多数据的，此时就会造成复杂度的提升，导致算法本身的效率下降。因此【insert】这个接口还是不推荐大家频繁使用

💬 通过上面一步步地演示，相信你对接口函数的重载形式如何去辨析一定有了一个自己的认知与了解，后面就不会讲这么详细了，读者可自己去试着测试看看各个重载示例

⑤ assign

讲完【insert】，我们再来瞧瞧【assign】，这个函数读者当做了解，不常用

• 它的功能就是起到一个 赋值 的效果，读者可了解一下文档

• 可以看到无论这个string对象s中有多少内容，在执行了【assign】之后就被覆盖成了新的内容。这里的话就演示一下这个了，其余的读者有兴趣可以自己去看看

⑥ erase

接下去就是【erase】这个接口，用得还是比较多的

• 首先第一个，其效果就是删除子序列，这个npos我们前面在介绍string类的构造函数时有讲到过，这里就不再做介绍了

string& erase (size_t pos = 0, size_t len = npos);

• 很简单，我们来演示一下，比如说我们从下标为1的地方开始往后删，因为第二个参数没有给出具体的值，所以使用的是缺省值npos，直接删到结尾

• 当然我们也可以指定删除的个数

• 不过【erase】用的更多的是头删，例如从第0个位置开始删，删一个

• 但是呢，我们可以这样去删，即传入这个首部迭代器的位置

• 当然，我们传入一个区间的迭代器也是可以的，例如这里传入了【begin】和【end】的位置就把整个字符串给删干净了

不过呢，这里还是要提一句，【erase】这个接口和【insert】一样，在修改原串的时候会造成大量的数据挪动，特别是在头删除的时候，需要挪动[n - 1]个数据

⑦ replace

接下去这个接口，会让你眼前一惊，因为有非常多的重载类型

• 不过这一块地话读者也不用担心，我们去记一下常用的就行，其余的要用了再查文档

• 简单地来演示一下，例如这里我们要从第2个位置开始替换，一共替换2个字符，将其替换成“ haha ”，以下就是替换后的结果

• 再来看看下一个，我们从首部迭代器的后一个位置开始，到尾部迭代器的前一个位置结束，将这些字符替换成“ eeee ”

💬 好，这里就简单演示两个，有兴趣的同学可以下去自己再看看

⑧ pop_back

有【push_back】，那就一定有【pop_back】，不过这是C++11新出来的

• 很简单，就是尾删一个字符

⑨ swap

接下去我们来看看【swap】这个接口。没错，它可以交换两个字符串

• 不过这一块的底层涉及到string对象的 深浅拷贝 问题，读者先了解一下

• 通过运行结果我们可以看到两个字符串确实发生了交换

这里再补充一道面试题

面试题01.03.URL化

• 本题如果这里的replace()接口的话较为合适，但是呢效率却不是很高，下面我介绍一种高效的办法，利用到的是我们上面所讲的+=，只需要去遍历一下这个字符串即可，然后判断其是否为【空格】即可，如果不是的话就直接拼接过来，如果是空格的话就拼接%20
• 这种方法大大地降低了时间复杂度，无需去考虑挪动数据的问题，大家可以参考一下这种做法

string replaceSpaces(string S, int length) {
    string str = "";
    for(int i = 0;i < length; ++i)
    {
        if(S[i] == ' '){
            str += "%20";
        }else{
            str += S[i];
        }
    }
    return str;
}

5）string类对象的其他字符串操作

然后我们再来看看有关string类对象的其他字符串操作接口

① c_str

• 假设现在我有一个名为test.cpp的文件，想要使用C语言中的fopen()打开它，但是呢却遇到了一些的问题

void TestCStr()
{
	string str = "test.cpp";
	fopen(str, "r");
}

• 编译之后发现报出错误说：不存在从“std:string"到"const char*”的适当转换函数，原因就在于我们这个【test.cpp】使用到是string类来进行存储，而如果你去查看 fopen 的文档的话，就可以发现 第一个参数所要传入的是一个字符串，这就是问题所在

FILE * fopen ( const char * filename, const char * mode );

此时呢【string】类给我们提供了一个接口函数叫做 c_str，帮助我们将 string对象 转换为 字符串

• 转换的形式就是下面这样。可以看出这个接口真的打通了C和C++之间的一堵墙，很好地起到了一个连通的效果

FILE* fout =  fopen(str.c_str(), "r");

💬 再拓展一个接口叫做【data】，仔细对比一下可以发现二者很类似，因为【data】是很早之前就定义好的接口，而【c_str】则是后面才被定义出来的，现在我们用的一般都是【size_t】

② substr

接下去是一个截取子串的接口

• 很好理解，就是从这个原本的string中截取出一部分的内容

• 当然如果不给长度的话默认使用的便是缺省值pos

③ find

然后我们来看看【find】接口，这个接口用的还是比较广泛的，值得学习一下

• 它的功能是在当前的 string对象 中查找第一次出现的【指定对象】或者【字符串 / 字符】

• 立马我们就来试一下，在string对象str中寻找【def】，返回的位置便是第一次所查找到的位置

• 当然也可以直接传入一个字符串

中转练武场：分割url

上面呢我们简单介绍了接口函数【substr】和【find】，现在立马通过具体的情景来使用一下它们

• 以下这个就是我们要分割的字符串，网站就是我们本文所讲的string类。现在呢我们要将其分割为三部分：一个是协议部分https，第二个是域名部分legacy.cplusplus.com/reference，第三个则是资源部分string/string/?kw=string

https://legacy.cplusplus.com/reference/string/string/?kw=string

• 那有的同学就懵逼了，只要怎么去割呢？还记得我们在C语言中所学习过的 字符串函数 吗，使用里面的【strcpy】、【strstr】、【strtok】就可以去完成这个逻辑，但是呢过程会非常地繁琐。况且我们在学习了 string类 的各种接口后，基本可以把这些函数给抛弃了

然后我们就尝试去分割一下这三部分，下面是整体的分割图示

string str("https://legacy.cplusplus.com/reference/string/string/?kw=string");

• 首先是对 协议 的一个分割，即我们要取到前面的https，那么就要找到://，那么此刻就可以使用到我们前面所学习过的find()函数，去记录下这个位置。
• 接下去我们就要去取出从头部到这个位置的子串了，很明显就是使用substr()，起始位置传入0即可，长度的话传入pos1，在讲解 数据结构之顺序表 的【size】时有说到过 当前位置的下标就是前面的数据个数

// 协议			
string protocol;
size_t pos1 = str.find("://");
if (pos1 != string::npos)
{
	protocol = str.substr(0, pos1);
}

• 接下去的 域名和资源名 我们可以一同去获取，首先需要调用的还是find()函数，先要确定的就是开始的位置，即这个【legacy】的l，其距离上一次的pos1刚好是后移3个的位置，所以我们从pos1 + 3开始即可，那么要到达的位置就是/，作为域名的第一次分割线。
• 接下去要确定的就是要取出的子串是那一部分，长度即为 尾部的pos2 - (pos1 + 3)
• 那么对于最后的【资源名】就很简单了，直接从pos2这个位置开始取，长度的话直接缺省即可，取到最后面，完全不需要考虑它的长度是多少

• 以下是代码

// 域名  资源名
string domain;
string uri;
size_t pos2 = str.find("/", pos1 + 3);
if (pos2 != string::npos)
{
	domain = str.substr(pos1 + 3, pos2 - (pos1 + 3));
	uri = str.substr(pos2);
}

最后来看下运行结果，就发现每一块都取出来了

• 当然，这样分割不仅仅是针对上面的这个网址，我们找一个百度的主页地址来构造string类的对象，再去运行可以发现依旧是没问题可以去做一个截取

string str("https://www.baidu.com/index.htm");

④ rfind

讲完了【find】，我们再来看看【rfind】

• 很明显，对于【find】的来说是从前往后寻找第一次出现的位置；但对于【rfind】来说呢则是从后往前寻找第一次出现的位置，那即为其最后一次出现的位置

• 简单测试一下，看到这个字符a最后一次出现的位置就是在下标为4的地方

• 其他重载形式大家可以自己去测试一下，这里就不做一一展示了，我们来看一下没找到的情况，可以看到返回了一个很大的值，如果你记性好的话一定知道这个是npos的值

• 我们可以再来看看官方的文档，可以看到如果出现了不匹配的情况的话，函数就会返回npos的值

接下去再来介绍四组接口，它们很类似

⑤ find_first_of

• 首先第一个是在当前的string对象中寻找匹配的任何字符，不过呢在知晓了其功能后你一定会感到这个接口的名字是不是取得不太对，应该叫 find_any_of 才对，不过呢可能是祖师爷在设计的时候突然走神了也说不定🤣

• 立马来看看案例

void TestFindFirstOf()
{
	string str("Please, replace the vowels in this sentence by asterisks.");
	size_t found = str.find_first_of("aeiou");
	while (found != string::npos)
	{
		str[found] = '*';
		found = str.find_first_of("aeiou", found + 1);
	}
	cout << str << endl;
}

• 结合运行结果和代码我们可以看到原串中包含aeiou五个元音字母的字符都会替换成了[*]。如果你有了解过 strtok() 的话就可以知道上面的代码逻辑和它的实现是存在着异曲同工之妙的

⑥ find_last_of

看完【find_first_of】，我们再来看看【find_last_of】

• 它的功能刚好和【find_first_of】和相反的，是从后一个字符开始查找

void TestFindLastOf()
{
	string str("Please, replace the vowels in this sentence by asterisks.");
	size_t found = str.find_last_of("aeiou");
	while (found != string::npos)
	{
		str[found] = '*';
		found = str.find_last_of("aeiou", found - 1);
	}
	cout << str << endl;
}

• 稍微改改代码，运行起来我们就可以看到，也是可以起到同样的效果

下面还有两个接口，和上面两个刚好是对立面

⑦ find_first_not_of

• 首先来看看第一个，通过文档我们可以看到是not match，即不匹配的情况

void TestFindFirstNotOf()
{
	string str("look for non-alphabetic characters...");

	size_t found = str.find_first_not_of("abcdefghijklmnopqrstuvwxyz ");

	if (found != string::npos)
	{
		cout << "The first non-alphabetic character is " << str[found];
		cout << " at position " << found << '\n';
	}
}

• 也是通过运行结果我们可以观察到，在字符串str中寻找26个英文字母 + 空格的时候，第一个找到的位置就是【12】，即为[-]

⑧ find_last_not_of

最后一个【find_last_not_of】，再坚持一下，马上就结束了(ง •_•)ง

void TestFindLastNotOf()
{
	string str("look for non-alphabetic characters...");

	size_t found = str.find_last_not_of("abcdefghijklmnopqrstuvwxyz ");

	if (found != string::npos)
	{
		cout << "The last non-alphabetic character is " << str[found];
		cout << " at position " << found << '\n';
	}
}

• 可以看到从后往前找的话最后一个就是[.]，它的位置即为36

6）string类对象的非成员函数重载

接下去我们再来看看string类对象的非成员函数重载

① operator+ ()

接下去我们来说operator+()，看到它是否有想起operator+=()呢，我们来对比辨析一下

• 可以看到对于operator+=()就是在后面追加字符串，不过operator+()起到的是一个拼接的效果

• 如果你有看过 类和对象的六大天选之子 的话，我在讲到日期的相加时间对比了【+】和【+=】的效果，前者在相加之后自身是不会有影响的，但是后者相加之后自身会受到影响。我们可以来看一下

• 如果是【+】的话，自身是不会受到影响的，我们要把结果放到另一个 string对象 中去

但是呢，二者的最本质区别还是在于这个效率问题，对于【+】而言，其底层在实现的时候因为无法对this指针本身造成修改，所以我们会通过拷贝构造出一个临时对象，对这个临时对象去做修改后返回，那我们知道返回一个出了作用域就销毁的对象，只能使用传值返回，此时又要发生一个拷贝

因此本接口其实不太推荐读者使用，了解一下即可，尽量还是使用【+=】来得好

② relational operators

接下去的话是一些关系运算符，这个我们在讲【日期类】的时候也是有自己模拟实现过，基本上实现了前面几个的话后面都是可以去做一个复用的，底层这一块如果读者想要深入了解的话就去看看日期类吧

• 其实大家仔细去看的话就可以发现这个接口的实现是非常冗余的，其实只给出第一中 string对象 和 string对象 比就可以了，后面的字符串其实在比较的时候可以去做一个 隐式类型转换

• 我这里来演示两个。可以看到如果是成立的话返回true，VS中用【1】来表示；反之则返回false，VS中用【0】来表示

• 再来看两个，可以发现有了这个之后我们在比较两个 string对象 的时候就非常方便了

下面两个的话我们可以一起说，其实你看到现在的话完全就不需要我说了，因为我们一直在使用这个东西，在对 string对象 进行操作的之后将其打印输出使用的就是重载之后的【流插入】

③ operator>>()

• 首先我们来说说【流提取】，其实就是和我们使用cin >>在做输入操作的时候一样，控制台会先去等待我们输入一个值

④ operator<<()

• 然后就是【流插入】，通过去缓冲区中拿取数据，然后将其显示在控制台上

⑤ getline

接下去再来说说【getline】，有了它我们可以到缓冲区中拿取一整行的数据

• 之前我们在学习C语言的时候使用scanf()，在读取字符串的时候经常是读到空格就结束了，而无法读取到后面的内容

然后我去网上找了很多的办法，一共是有以下三种

① 首先的话就是使用一种特殊的格式化输入

scanf("%[^\n]", s1);

② 第二种就是通过 gets_s 来进行读取

gets_s(s1);

③ 第三种乃是通过文件结束符EOF来进行判断，其是直接读取到换行符\n为止

while ((scanf("%s", s1)) != EOF)
{
	printf("%s ", s1);
}

💬 但是呢，在我们学习了getline()函数后，就不需要这么麻烦了，其可以在缓冲区中读取一整行的数据，而不会遇到空格就截止

三、string的模拟实现

对STL中的string类有了一个基本的认识后，本模块，我会带着你从0 ~ 1去模拟一下s库中string的这些接口，当然是比较常用的一些，代码量大概600行左右

1、前情提要

• 首先第一点，为了不和库中的string类发生冲突，我们可以在外层包上一个名称为bit的命名空间，此时因为作用域的不同，就不会产生冲突了，如果这一块有点忘记的同学可以再去看看 namespace命名空间

namespace bit
{
	class string {
	public:
		//...
	private:
		size_t _size;
		size_t _capacity;
		char* _str;
	};
}

• 接下去呢，就在测试的test3.cpp中包含一下这个头文件，此时我们才可以在自己实现的类中去调用一些库函数

#include <iostream>
#include <assert.h>
using namespace std;

#include "string.h"

2、Member functions —— 成员函数

构造函数

好，首先第一个我们要来讲的就是【构造函数】

• 首先我们从无参的构造函数开始讲起，看到下面的代码，你是否有想起了 C++初始化列表，我们默认给到 _size 和 _capacity 的大小为，然后给字符数组开了一个大小的空间，并且将其初始化为\0

// 无参构造函数
string()
	:_size(0)
	, _capacity(0)
	,_str(new char[1])
{ 
	_str[0] = '\0';
}

• 然后我们立即来测试一下，因为我们自己实现的 string类 是包含在了命名空间bit中的，那么我们在使用这个类的时候就要使用到 域作用限定符::

bit::string s1;

然后打印一下这个string对象发现是一个空串

• 有无参，那一定要有带参的，可以看到这里我们在初始化_size的时候先去计算了字符串str的长度，因为_size取的就是到 \0 为止的有效数据个数（不包含\0），那么【strlen】刚好可以起到这个功能
• 然后在_str这一块，我们为其开出的空间就是 容量的大小 + 1，最后的话还要在把有效的数据拷贝到这块空间中，使用到的是【strcpy】

// 有参构造函数
string(const char* str)
	: _size(strlen(str))
	, _capacity(_size)
	,_str(new char[_capacity + 1])
{
	// 最后再将数据拷贝过来
	strcpy(_str, str);	
}

• 同样地来进行一个测试

💬 不过呢，我这里再给出一个改进的版本

• 此处没有使用到初始化列表，而是在直接写在函数体内，注意观察这里的形参部分，这里运用到的知识点为 C++缺省参数，如果忘记了的同学记得去回顾一下
• 如果外界在构造对象的时候不进行传参，此时使用的便是这个默认的参数，“”代表的是一个空的字符串，但是无论怎样，对于一个字符串来说末尾是一定有\0的，此刻你可以将它带入下面的表达式，发现算出后的结果与前面无参是一样的

// 构造函数
string(const char* str = "")
{
	_size = strlen(str);
	_capacity = _size;
	_str = new char[_capacity + 1];
	memcpy(_str, str, _size + 1);
}

• 可能有的读者注意到了这个 memcpy()，如果有度过 字符串函数与内存函数 一文的话就可以清楚它们的区别在哪里了，对于strcpy()来说拷贝到\0就会发生终止而不会拷贝了，这是我在测试一些极端场景的时候考虑到的

可以看到换回【strcpy】的时候\0后面的内容就不会去进行一个拷贝了，不过这里其实体现得不是很明显，我们在下面的 拷贝构造、赋值运算符重载 中会继续提到这个

💬 有同学觉得上面的缺省参数很是奇妙，于是提出能不能写成下面这样

• 这肯定是不可以的，从运行结果我们可以看出虽然运行出来也是空串的结果，但是这么写的话总归不太好

string(const char* str = "\0")

• 但是呢对于下面这种就更不可以了，因为这在调用【strlen】的时候就会触发 空指针异常 的问题

string(const char* str = nullptr)

拷贝构造函数

马上，我们就来聊聊有关【拷贝构造函数】的内容

• 在 深度探索类的六大天选之子 中我们有提到过若是一个类在没有显示定义拷贝构造对于内置类型不做处理，而对于自定义类型会去调用 类中默认提供的拷贝构造函数 此时就会造成浅拷贝的问题

• 我们可以通过调试来浅浅地看一下，便可以看出浅拷贝所带来的危害，光是在调用析构这一块就出现了 二次析构 的问题

• 所以我们要自己去做一个实现，可以看到我们这里在进数据的拷贝时也是使用到了memcpy()

string(const string& s)
{
	_str = new char[s._capacity + 1];
	memcpy(_str, s._str, s._size);
	_size = s._size;
	_capacity = s._capacity;
}

• 通过调试再去观察的话，我们可以发现，此时 对象s1 和 对象s2 中的数据存放在不同的空间中，此时去修改或者是析构的话都不会受到影响

下面呢还有一个新的版本，这一块我放到【赋值重载】去进行讲解

// 拷贝构造函数(新版本)
string(const string& s)
	: _str(nullptr)
	, _size(0)
	, _capacity(0)
{
	string tmp(s._str);
	// tmp出了当前函数作用域就销毁了，和this做一个交换
	this->swap(tmp);
}

赋值运算符重载

对于赋值运算符重载这一块我们知道它也是属于类的默认成员函数，如果我们自己不去写的话类中也会默认地生成一个

• 但是呢默认生成的这个也会造成一个 浅拷贝 的问题。看到下面图示，我们要执行s1 = s3，此时若不去开出一块新空间的话，那么s1和s3就会指向一块同一块空间，此时便造成了下面这些问题
  • 在修改其中任何一者时另一者都会发生变化；
  • 在析构的时候就也会造成二次析构的；
  • 原先s1所指向的那块空间没人维护了，就造成了内存泄漏的问题

• 那么此时我们应该自己去开出一块新的空间，将s3里的内容先拷贝到这块空间中来，然后释放掉s1所指向这块空间中的内容，然后再让s1指向这块新的空间。那么这个时候，也就达成了我们所要的【深拷贝】，不会让二者去共同维护同一块空间
• 最后的话不要忘记去修改一下s1的【_size】和【_capacity】，因为大小和容量都发生了改变

下面是具体的代码，学习过 类的六大天选之子 的同学应该不陌生

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;
}

但是呢，就上面这一种写法并不是最优的，我们来看看下面的这种写法

• 很多同学非常地震惊，为何这样子就可以做到【深拷贝】呢？

// 赋值重载(pua版本)
string& operator=(const string& s)
{
	if (this != &s)
	{
		string tmp(s);
		this->swap(tmp);
	}
	return *this;
}

• 有关这个swap()函数，本来是应该下面讲的，既然这里使用到了，那就在这里讲吧，这个接口我在上面并没有介绍到，但是在讲 C++模版 的时候有提到过库中的这个 swap() 函数，它是一个函数模版，可以 根据模版参数的自动类型推导去交换不同类型的数据
• 可以看到在我们自己实现的这个swap(string& s) 函数中就去调用了std标准库中的函数然后交换一个string对象的所有成员变量

void swap(string& s)
{
	std::swap(_str, s._str);
	std::swap(_size, s._size);
	std::swap(_capacity, s._capacity);
}

• 接下去来解释一下这里的原理，我们在这个赋值重载的函数内部调用了拷贝构造去获取到一个临时对象tmp，然后再通过swap()函数去交换当前对象和tmp的指向，此时s1就刚好获取到了赋值之后的内容，而tmp呢则是一个临时对象，出了当前函数的作用域后自动销毁，那么原本s1所维护的这块空间刚好就会销毁了，也不会造成内存泄漏的问题

💬 那有同学就说：这个妙啊！太妙了！

• 哈哈，不知读者有没有听过最近很火的一个词叫做【PUA】

“PUA”的原理，就是打击你的自尊，摧毁你的独立思考能力，让你觉得自己一无所事，
然后对方趁虚而入，让你产生依赖，让你觉得只有对方才能帮助自己，从而被对方操控。

• 泡面🍜的话相信大家都有吃过，假设说呢有这么一个场景：你呢是家里的哥哥，你还有一个弟弟，这一天的中午你很想吃冰箱里的那桶泡面，但是呢妈妈又不让吃，于是你就和你弟弟说：“冰箱里有一桶很好吃的泡面，你快去泡一下试试看”。那此时你傻傻的弟弟就立马去做了，当他泡完的时候呢你再去找你的妈妈告状，于是这个时候弟弟就被狠狠地骂了一顿(╯▔皿▔)╯
• 此时这碗泡面就没人吃了，于是这个时候你就乘虚而入把这碗泡面给吃了，但是呢又不想洗碗，于是又把你弟弟给叫了过来，说：“要不你把这个碗去洗了，晚上我给你买雪糕吃🍦”。听到雪糕后你的弟弟又精神起来了，马上就把碗去给洗了

• 透过上面这个小例子读者应该对新的这种拷贝构造有了一定的理解：反正你这个tmp对象出了作用域也要销毁的，你手上呢刚好有我想要的东西，那我们换一下吧，此时我得到了我想要的东西，你呢拿到了我的东西，这块地址中的内容刚好就是要销毁的，那tmp在出了作用域后顺带就销毁了，这也就起到了【一石二鸟】的效果

好，我们通过这个调试来观察一下，可以看到就是这个“PUA技术”，很好地达成了我们的目标

💬 但是呢，我觉得上面的这种PUA还不够，还可以再 “精妙” 一些，我们一起来看一下下面这个版本

• 可以看到，真的是非常简洁，两行代码就足够了，那为什么可以起到这样的效果呢？原因其实就在于这个形参部分，可以看到我并没有使用像上面那样的【引用传参】，而是直接使用的传值传参
• 那仔细学习过【类和对象】的同学一定可以知道对于【传值传参】的话会先去调用拷贝构造拷贝出一个临时的对象，那么这不就是我们在写上面一个版本的时候在函数内部去调用拷贝构造所做的事吗？那么当外界在给这个函数传递参数对象的时候，此时这个tmp便是外面这个对象的一个临时拷贝，我们直接去操作这个对象的时候也可以到达同样的效果

// 赋值重载(究极pua版本)
string& operator=(string tmp)
{
	this->swap(tmp);
	return *this;
}

一样，我们通过调试来看就可以看得很清晰，一开始按F11的时候我们可以看到进入到了拷贝构造函数内部，这个时候其实就是因为传值传参去调用拷贝构造的缘故

💬 此时我们就可以去谈谈在一模块所讲到的这个【新版本的拷贝构造函数】

• 这里我把代码再放一遍，读者在看到赋值重载之后再来看这个应该就没有那么陌生了

// 拷贝构造函数(新版本)
string(const string& s)
	: _str(nullptr)
	, _size(0)
	, _capacity(0)
{
	string tmp(s._str);
	// tmp出了当前函数作用域就销毁了，和this做一个交换
	this->swap(tmp);
}

• 我在这边主要想讲的还是这个初始化列表的问题，读者一定知道如果我们没有手动地去初始化成员变量的话，对于内置类型编译器是不做处理的，对于自定义类型则会去调用默认生成的拷贝构造，那交给编译器去做安全吗？当然是极度地不安全

string(const string& s)
{
	string tmp(s._str);
	// tmp出了当前函数作用域就销毁了，和this做一个交换
	this->swap(tmp);
}

• 通过调试我们可以观察到，当直接去调用拷贝构造的时候，编译器对当前的对象做了一个初始化的工作，于是在析构的时候就没有出现问题，但是继续执下去到达我们上面的赋值=的时候，因为传值传参的缘故首先会去调用这个拷贝构造拷贝一份临时对象，但是呢在调试的时候可以发现编译器并没有去对当前对象中的成员变量做一个初始化的工作，在执行swap()函数后这个没被初始化的对象就交给tmp来进行维护了，但是呢tmp在出了作用域之后又要销毁，那么此时在执行析构函数的时候便会出问题了，去释放了一块并没有初始化的空间，一定会出现问题的！

💬 所以我们还是不能去相信编译器所做的一些工作，而是要自己经手去做一些事，避免不必要的麻烦

析构函数

最后的话就是析构函数这一块，前面在调试的过程中我们已经看到很多遍了，此处不再细述

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

2、Element access —— 元素访问

基本的成员函数我们已经讲完了，string对象也构造出来了，接下去我们来访问一下对象里面的内容吧

operator[ ]

• 首先最常用的就是这【下标 + [ ]】的形式去进行一个访问，那很简单，我们通过当前所传入的下标值去访问对应的数据即可
• 下面的话有两种实现形式，一个是可读可写的，一个则是可读不可写的

// 可读可写
char& operator[](size_t pos)
{
	assert(pos < _size);
	return _str[pos];
}

// 可读不可写
const char& operator[](size_t pos) const
{
	assert(pos < _size);
	return _str[pos];
}

• 里面我们就通过循环来访问一下，这里的size()函数和流插入我们会在下面讲到

• 此时我们去调用的时候可读可写的版本，是可以在边访问的时候去做一个修改的，效果如下

• 但是呢，如果我在定义这个对象的时候在前面加上一个const的话此时这个对象就具有常性了，在调用operator[]的时候调用的便是 可读不可写 的那一个，所以此刻我们去做一个修改操作的话就会出问题了

const bit::string s2("world");

• 通过调试我们可以观察到编译器在调用这一块会默认去匹配最相近的重载函数非常得智能

3、Iterator —— 迭代器

那经过上面的学习我们可以知道，要去遍历访问一个string对象的时候，除了【下标 + []】的形式，我们还可以使用迭代器的形式去做一个遍历

• 而对于迭代器而言我们也是要去实现两种，一个是非const的，一个则是const的

typedef char* iterator;
typedef const char* const_iterator;

• 这里的话我就实现一下最常用的【begin】和【end】，首位的话就是_str所指向的这个位置，而末位的话则是_str + _size所指向的这个位置

iterator begin()
{
	return _str;
}

iterator end()
{
	return _str + _size;
}

• 实现了普通版本的迭代器之后，我们再来看看常量迭代器。很简单，只需要修改一下返回值，然后在后面加上一个【const成员】，此时就可以构成函数重载了

const_iterator begin() const
{
	return _str;
}

const_iterator end() const
{
	return _str + _size;
}

• 首先我们来看一下这个普通的迭代器，成功地遍历了这个string对象

• 那么对于常对象来说的话，就要使用常量迭代器来进行遍历，但你是否觉得这个迭代器的长度过于长了呢？

• 这一点我们在上面也讲到过了，使用C++11中的auto关键字进行自动类型推导即可

auto cit = s2.begin();

之前我们有讲过，一个类只要支持迭代器的话那一定支持范围for，马上我们来试试看吧

• 分别去遍历一下这两个 string对象 ，可以看到都不成问题

for (auto ch : s1)
{
	cout << ch << " ";
}
cout << endl;

for (auto ch : s2)
{
	cout << ch << " ";
}

这个方式去遍历的话还是很方便的，必须安利一波✌

4、Capacity —— 容量

下面四个接口我们一起来看看，然后一同测试

size

• 首先是 size()，这里的话我们直接返回_size即可，因为不会去修改成员变量，所以我们可以加上一个【const成员】

size_t size() const
{
	return _size;
}

capacity

• 对于 capacity() 也是同样的道理

size_t capacity() const
{
	return _capacity;
}

clear

• 对于 clear() 而言就是去清除当前对象的数据，我们直接在_str[0]这个位置放上一个\0即可，并且再去修改一下它的_size = 0即可
• 不过这个接口来说我们不要去加【const成员】，因为修改了其成员变量_size

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

empty

• 对于 empty() 来说呢就是对象中没有数据，那么使用0 == _size即可

bool empty() const
{
	return 0 == _size;
}

💬 然后我们来测试一下

reserve

然后我们来看【reserve】扩容

• 很明显，只有当这个 新容量大于旧容量的时候，才会去选择去开空间，这里的扩容逻辑和我们在实现旧版本的拷贝构造函数时类似的：也是先开出一块新的空间（这里主要使用这个newCapacity 去开），然后再将原本的数据拷贝过来，释放旧空间的数据后让_str指向新空间即可。最后的话不要忘了去更新一下容量大小
• 但是呢对于VS下如何去实现 1.5倍 的扩容就不做展开了，读者有兴趣可以自己试试

// 扩容(修改_capacity)
void reserve(size_t newCapacity = 0)
{
	// 当新容量大于旧容量的时候，就开空间
	if (newCapacity > _capacity)
	{
		// 1.以给定的容量开出一块新空间
		char* tmp = new char[newCapacity + 1];
		// 2.将原本的数据先拷贝过来
		memcpy(tmp, _str, _size);
		// 3.释放旧空间的数据
		delete[] _str;
		// 4.让_str指向新空间
		_str = tmp;
		// 5.更新容量大小
		_capacity = newCapacity;
	}
}

马上来做一个测试

通过调试再去看一下，可以发现_str的空间确实发生了一个很大的改变

resize

然后我们再来讲讲【resize】，博主觉得下面的这个算法是比较优的，读者可以参考一下

• 首先我们来分析一下，对于【resize】而言主要对对象中的数据去做一个变化，那就需要去进行分类讨论
  • 如果这个 newSize < _size 的话，那我们要选择去删除数据
  • 如果这个 newSize > _size，但是呢 newSize < _capacity 的话，此时要做的就是新增数据但是呢不去做扩容
  • 如果这个 newSize > _size 的话，我们便要选择去进行扩容了

• 在分析完了之后，我们立即来实现一下相关的代码。可以看到，一上来我就直接去判断了newSize 是否大于_size，然后在内部又做了一层判断，只有当newSize > _capacity时，才去执行【reserve】的扩容逻辑
• 如果newSize并没有超过容量大小的话我们要做的事情就是去填充数据，这里用到的是一个内存函数【memset】
  • 我们从_str + _size 的位置开始填充；
  • 填充的个数是newSize - _size个；
  • 填充的内容是c
• 若是newSize <= _size的话，我们所要做的就是去截取数据，到newSize为止直接设置一个 \0，然后更新一下当前对象的_size大小

// 改变大小
void resize(size_t newSize, char c = '\0')
{
	// 1.当新的_size比旧的_size来得小的话，则进行删除数据
	if (newSize > _size)
	{
		// 只有当新的size比容量还来的大，才去做一个扩容
		if (newSize > _capacity)
		{
			reserve(newSize);
		}
		// 如果newSize <= _capacity，填充新数据即可
		memset(_str + _size, c, newSize - _size);
	}

	// 如果 newSize <= _size，不考虑扩容和新增数据
	_size = newSize;
	_str[newSize] = '\0';
}

💬 马上我们就来分类测试一下

• 首先是resize(8)，可以看到这里发生了一个数据截断的情况，_size也相对应地发生了一个变化

• 接下去的话是resize(12)，这并没有超过其容量值，但是却超出了_size 大小，所以我们要去做一个扩容

• 最后一个则是resize(18)，此时的话就需要去走一个扩容逻辑了，并且在扩完容之后还要再进一步去填充数据

5、Modifiers —— 修改器

好，接下去我们来讲讲修改器这一块

push_back

• 首先第一块的话简单一点，我们去追加一个字符，那首先要考虑到的也是一个扩容逻辑，因为我们是一个字符一个字符去进行插入的，那么当这个_size == _capacity的时候，就要去执行一个扩容的逻辑了，这边的话是运用到了这个三目运算符，若是容量的大小为0的话，默认开个大小为4的空间就可以了；其他的情况都是以2倍的形式去进行扩充
• 最后在扩完容之后我们就在末尾去增加数据了，因为_size指向的就是 \0 的位置，所以就把字符放在这个位置上就可以了，顺带地记得去后移一下这个_size，再放上一个 \0

// 追加一个字符
void push_back(char ch)
{
	// 如果数据量大于容量的话，则需要进行扩容
	if (_size == _capacity)
	{ 	
		reserve(_capacity == 0 ? 4 : _capacity * 2);
	}
	_str[_size++] = ch;
	_str[_size] = '\0';
}

• 立马来测试一下看看

append

• 接下去的话是【append】，要追加的是一个字符串，所以我们要先去算出它的长度，接下去判断一下在加上这个长度后是否要去做一个扩容，最后的话还是通过我们熟悉的【memcpy】通过字节的形式一一拷贝到_str + _size的位置（注意拷贝len + 1个，带上最后 \0），最后再把大小_size给增加一下即可

// 追加一个字符串
void append(const char* s)
{
	int len = strlen(s);	// 获取到待插入字符串的长度
	// 若是加上len长度后超出容量大小了，那么就需要扩容
	if (_size + len > _capacity)
	{
		reserve(_size + len);
	}

	// 将字符串拷贝到末尾的_size位置
	memcpy(_str + _size, s, len + 1);
	// 大小增加
	_size += len;
}

• 也是一样来测试一下

读者一定会觉得上面的函数调用太过于冗余，不过没关系，我们还有【+=】呢

operator+=(char ch)

• 首先的话是去【+=】一个字符，这里我们直接复用前面的push_back()接口即可，最后因为【+=】改变的是自身，所以我们return *this，那么返回一个出了作用域不会销毁的对象，可以采取 引用返回 减少拷贝

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

operator+=(const char* s)

• 而对于【+=】一个字符串，我们则是去复用前面的append()即可

string& operator+=(const char* s)
{
	append(s);
	return *this;
}

💬 立马来测试一下吧

从pos位置开始插入n个字符

接下去我们就要来实现一下【insert】这个接口了

• 不过在这之前呢我们先要去声明并初始化一个静态的成员变量npos，它是最大的无符号整数值。但是对于 静态的成员变量 来说我们需要 在类内声明并且在类外进行初始化

// 类内声明
static size_t npos;

// 类外初始化
size_t string::npos = -1;

• 首先第一个的话就是要在pos位置插入n个字符

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

• 因为这里会传入一个pos位置，所以第一步我们就是要去考虑这个pos位置是否合法

assert(pos <= _size);

• 接下去第二步的话就是去考虑过扩容的问题了，如果_size + n之后的大小大于_capacity的话那就要调用【reserve】接口去实现一个扩容的逻辑了

// 考虑扩容
if (_size + n > _capacity)
{
	reserve(_size + n);
}

• 第三步呢并不是直接去插入数据，而是要先给需要插入的n个字符腾出位置。从_size位置开始，让字符以n个单位地从后往前挪即可，若是从前往后挪的话就会造成覆盖的问题

// 挪动数据
size_t end = _size;
while (end >= pos)
{
	_str[end + n] = _str[end];
	--end;
}

• 不过呢，我们在这里还要考虑一种极端的情况，如果这个pos == 0的话，也就是在这个位置开始插入数据，那也就相当于头插，此时需要将全部的数据向后进行挪动，可是呢当这个end超出pos的范围时，也就减到了-1，但是呢这个end的数据类型则是【size_t】，为一个无符号整数，我们知道对于无符号整数来说是不可能为负数的，那么这个时候就会发生一个轮回，变成最大的无符号正数

• 我们可以来看看当这个end在不断减少直至减到0的时候就会突然变成一个很大的数字，这个其实就是npos的值了，此时就会造成一个死循环，导致程序崩溃

• 所以我们应该在循环的结束条件中加上一个end != npos才对

// 挪动数据
size_t end = _size;
while (end >= pos && end != npos)
{
	_str[end + n] = _str[end];
	--end;
}

• 当这个挪动的逻辑结束后，我们就可以从pos这个位置去插入n个字符了。最后再去更新一下这个_size的大小即可

// 插入n个字符
for (size_t i = 0; i < n; i++)
{
	_str[pos + i] = ch;
}
_size += n;

从pos位置开始插入一个字符串

void insert(size_t pos, const char* s)

• 对于在【pos位置插入一个字符串】来说，其他逻辑和上面这个接口都是一样，也是要经过 扩容、移位、放数据 这些操作，只是这里在放数据的时候换成了字符串而言

// 插入字符串
for (size_t i = 0; i < len; i++)
{
	_str[pos + i] = s[i];
}
_size += len;

删除从pos位置开始的len个有效长度字符

void erase(size_t pos, int len = npos)

• 意思很简单，就是从pos位置开始去删，删除len个有效长度的字符，那这几个字符就相当于是不要了，但是呢后面的字符串还是要的，所以有的同学就会想到用这个 拼接 的方法去完成
• 但是呢没必要这样，这只会增加算法的复杂性，对于【erase】来说更多地还是去做一个 移位覆盖

读者可以通过下面的算法分解图去思考一下代码该如何书写，我们是从【w】这个位置开始删除长度为3的有效字符

• 但是呢，我们还要考虑到一些特殊的情况，例如说我们要取的长度len很大很大，甚至是最大的无符号整数npos，或者呢在pos + len之后的长度超出了当前_size的大小，此时我们可以直接对pos之后的字符去做一个截断的操作，让这个位置变成新的_size

下面就是具体的代码展示，对于正常的情况而言，最后呢不要忘记了在覆盖字符后去改变一下这个_size的大小

// 删除从pos位置开始的len个有效长度字符
void erase(size_t pos, int len = npos)
{
	if (len == npos || pos + len > _size)
	{
		_size = pos;
		_str[_size] = '\0';
	}
	else
	{
		size_t end = pos + len;
		while (end <= _size)
		{
			_str[pos++] = _str[end++];
		}
		_size -= len;
	}
}

• 首先呢我们从第五个位置开始，去删除长度为5的有效字符

• 接下去呢我们再从pos == 2的位置开始，删除长度为30的字符，那这个就是pos + len > _size的情况

• 那如果第二个参数不传递呢？那使用的便是缺省值【npos】，这就是len == npos的情况

swap

• 对于【swap】函数我们在上面已经有讲解过了，此处不再过度赘述

void swap(string& s)
{
	std::swap(_str, s._str);
	std::swap(_size, s._size);
	std::swap(_capacity, s._capacity);
}

6、String Operations —— 字符串操作

然后再来讲讲有关字符串的一些操作

c_str

• 首先的话就是这个【c_str】，可以看到上面我在测试完一个结果后都会去cout << s << endl;打印一下，如果你就使用了上面这些代码的话，一定是会报错的，因为流插入运算符<<和 string类对象并没有对应的重载函数，这一块我后面在讲流插入的时候会提到，报错的同学可以先用下面这种

const char* c_str()
{
	return _str;
}

• 这个【c_str】就是string类的对象转换成为字符串，那么我们知道对于字符串而言与流插入<<是有重载的，所以才可以起到一个很好地匹配

cout << s1.c_str() << endl;

从pos位置开始找指定的字符

• 这个很简单，就是去遍历一下当前对象中的_str，若是在遍历的过程中发现了字符ch的话就返回这个位置的下标，如果遍历完了还是没有找到的话就返回npos这个最大的无符号数

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

从pos位置开始找指定的字符串（找子串）

• 上面是在找单独的一个字符，现在我们来找找一个字符串，那么string类的对象本身就是一个字符串，这也就演化成了在一个字符串中寻找一个子串，还记得我们在 数据结构 | 串的模式匹配问题 中所讲到的如何在一个主串中寻找子串，那时我们有谈到【暴搜】和【KMP】两种写法
• 不过在这里呢，我直接使用的是C语言中的库函数 strstr，这个的话我们在 字符串函数与内存函数解读 的时候也有讲解并模拟过，如果找到了的话就会返回子串第一次出现在主串中的指针。那我们如果要去计算这个指针距离起始位置有多远的话使用指针 - 指针的方式即可。那如果没找到的话我们返回【npos】即可

size_t find(const char* s, size_t pos)	const
{
	assert(pos < _size);
	char* tmp = strstr(_str, s);
	if (tmp)
	{
		// 指针相减即为距离
		return tmp - _str;
	}
	return npos;
}

那我们立马来测试一下

• 首先是去找一个字符a，我们从第0个位置开始找

size_t pos = s1.find('a', 0);

• 再来试试去找一个字符串

从pos位置开始取len个有效字符（取子串）

上面是去匹配子串，现在我们要将这个子串给取出来，要如何去取呢？

string substr(size_t pos, size_t len = npos)

• 首先要考虑到的是，如果我们从pos位置开始所要取的子串长度大于剩余的串长，那最多能取到的有效范围也就是从pos位置开始的到末尾的_size结束这段距离，所以当这个所取长度过长的话，我们就要考虑去更新一下取子串长度的有效范围

• 可以看到，我以这个n作为可取的子串长度，一开始得让其等于传入进来的len长，因为如果这个所取长度没有超出有效范围的话，我们所用的还是len
• 但是如果呢这个长度超出了有效范围后，我们便要去更新这个n = _size - pos

size_t n = len;
if (len == npos || pos + len > _size)
{
	// 就算要取再大的长度，也只能取到pos - _size的位置
	n = _size - pos;
}

• 那接下去的话我们就可以去取这个子串了，使用循环的方式从pos位置开始取，取【n】个即可，然后追加到这个临时的 string对象 中去，最后呢再将其返回即可，那我们返回一个出了作用域就销毁的临时对象，只能使用【传值返回】，而不能使用【传引用返回】

string tmp;
tmp.reserve(n);
for (size_t i = pos; i < pos + n; i++)
{
	tmp += _str[i];
}
return tmp;

• 测试一下可以看到，我们从第5个位置开始取，取5个有效字符，最后拿到【world】

• 再来试一下这个len很大的情况，此时可以看到我们取到的还是这个【world】

• 我们可以通过调试来看看这个n是怎么发生变化的

• 当然，你也可以不传递，此时这个len取的就是默认的【npos】

7、Non-member function overloads —— 非成员函数重载

最后的话再来模拟一些【非成员函数重载】，使用到的也是非常多

relational operators

这里有很多的关系运算符我们来模拟实现一下

① 小于

bool operator<(const string& s)

• 首先读者要清楚的是我们在比较两个 string对象 的时候，所使用的规则并不是去比较它们的长度，而是去比较它们的ASCLL码值，这里我首先要介绍的第一种方法就是采取 双指针 的形式去进行一一比较，有点类似于我们所讲过的 数据结构 | 归并排序 的遍历思维
• 在遍历的过程中，只有当 前一个对象中的字符 出现小于 后一个对象中的字符 时，才返回true；出现大于的情况就返回false；如果是相等情况的话则双指针继续向后进行遍历，直接有一个遍历结束位置跳出循环

size_t i1 = 0;
size_t i2 = 0;
while (i1 < _size && i2 < s._size)
{
	if (_str[i1] < s._str[i2])
	{
		return true;
	}
	else if (_str[i1] > s._str[i2])
	{
		return false;
	}
	else
	{
		i1++;
		i2++;
	}
}

• 当这个循环跳出的时候，我们可以将比较的情况分为以下三种
  • 第一种是两个对象的长度是相等的，此时双指针都遍历结束，那return false
  • 第二种是后一个遍历结束，但是前一个没有结束，那就是前一个来的大，那return false
  • 第三种则是前一个遍历结束，但是后一个没有结束，那就是后一个来的大，是符合的，所以return true

• 那我下面给出两种判断的方式，第一种呢则是去比较两个指针的位置

return i1 < _size && i2 == s._size;

• 第二种呢就方便一些，直接去比较两个对象中数据个数的大小即可

return _size < s._size;

不过呢，上面这种方法虽然易懂一些，但是并不精炼

• 下面我再介绍一种方法，可读性不是那么强，考察到了对【三目运算符】的理解

bool operator<(const string& s)
{
	int ret = memcmp(_str, s._str, _size < s._size ? _size : s._size);
	return ret == 0 ? _size < s._size : ret < 0;
}

• 还记得我们讲过的 memcmp 吗？这是一个内存比较函数，其是以字节的形式去一个个进行比较，那比较的长度我们可以先以二者中小的那个为准，所以后面的三目运算符起到的就是这个作用
• 接下去呢，在两个对象相同的部分比较完后，再去比较后面的那些部分呢，所以需要这个ret == 0为前提条件，然后比较的便是二者的_size大小；那如果这个ret != 0的话我们只需要返回小于0的那种情况即可

② 等于

• 然后再来讲讲operator==，这里我们可以使用到的是【逻辑运算符】先去排除掉一部分的情况，因为若是两个对象的_size都不相同的话，那一定是不会相同的
• 那么在_size相同的情况下，我们再去使用memcpy()根据字节去一一比价两个对象中_str的内容，只有其返回值为0的时候才表示两个对象完全相同

bool operator==(const string& s)
{
	return _size == s._size && memcmp(_str, s._str, s._size) == 0;
}

那有了上面的【小于】和【等于】之后，下面的我们就可以去做一个复用了，这一块我们在 类的六大天选之子 中讲解日期类的关系运算符重载时有提到过

③ 小于等于

bool operator<=(const string& s)
{
	return *this < s || *this == s;
}

② 大于

bool operator>(const string& s)
{
	return !(*this <= s);
}

② 大于等于

bool operator>=(const string& s)
{
	return !(*this < s);
}

② 不等于

bool operator!=(const string& s)
{
	return !(*this == s);
}

立马来测试一下吧

最后的话再来补充两个【流插入】和【流提取】，也是非常地重要

operator<< 流插入

• 那有认真学习过【类和对象】的话，就可以知道为了不让this所指向的对象默认成为第一个参数的话，我们需要将这个函数实现到类外来，如果要访问类内私有成员的话，就可以使用到【右元】这个东西，不过呢我们不建议使用这个，会破坏类的封装性

// 流插入
ostream& operator<<(ostream& out, const string& s)
{
	for (size_t i = 0; i < s.size(); i++)
	{
		out << s[i];
	}
	return out;
}

• 还有一点要提醒的是对于这个流插入来说我们是一定要进行引用返回的，这样就不会去调用拷贝构造了。因为在库中对这个函数是做了一个 防拷贝 的效果，即在后面加上一个= delete

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

💬 好，那到这里的话，我们是时候来讲讲这个cout << s.c_str() 和 cout << s 的区别了

• c的字符数组, 以\0为终止算长度
• string不看\0, 以size为终止算长度

operator>> 流提取【⭐】

接下去再来看看这个【>>流提取】

• 这里首先要注意的一点就是第二个参数的前面不能和【<<流插入】一样加const，因为我们会去修改这个 s

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

【第一版本】：无法读取 空格 和 换行符

• 首先可以来看下代码，我们通过cin >> ch来将缓冲区内的字符放到【ch】中，接着以换行作为结束读取的标志来不断读取下一个字符并拼接到对象 s 中去

istream& operator>>(istream& in, string& s)
{
	char ch;
	in >> ch;
	while (ch != '\n')
	{
		s += ch;
		in >> ch;
	}
	return in; 
}

• 下面我展示一下这个写法的两种BUG，一个是在读取到\n的时候缓冲区会继续等待字符的输入，而不是结束读取

• 还有一种则是在读取的过程中如果读到空格了，是不会识别到的，而是会继续读取下一个字符

【第二版本】：使用get()读取到流中流中的空格和换行符

• 在流提取istream中有一个接口叫做【get】，我们使用它就可以读取到空格和换行符了

代码如下，可先参考

// 流提取
istream& operator>>(istream& in, string& s)
{
	char ch = in.get();

	while (ch != '\n')	 // 以换行作为分隔符
	{
		s += ch;
		ch = in.get();
	}
	return in;
}

• 然后我们通过调试来观察一下就可以发现我们使用ch = in.get()读取到了中间的空格，而且在读取到\n换行符的时候也成功退出了循环

【第三版本】：clear()清理缓冲区内的字符

• 接下去我们再来看一种现象，就是当我们重复去操作同一个对象的时候，此时可以看到缓冲区内的字符并没有去做一个清除，所以我们后面再去输入的时候就会造成一个追加的现象

• 还记得我们在上面讲到过的clear()吗，用来清理 string对象 中的数据

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

• 在加上这个后，可以发现第二次再去输入的时候就不会造成追加的现象了

• 我们也可以通过调试来进行观察

【第四版本】：预存数组减少扩容

• 难道写成上面这样就好了吗，我们知道当这个 string对象 的容量不够的时候可以去做一个扩容，那若是这个对象本身的大小就很大的话随着s += ch就会去产生频繁扩容的现象，这其实是不好的

💬 那有同学说：那我们在读取数据之前就开出一个很大的数组来不就好了，这样肯定能装得下无需扩容了

• 那我想问：如果这个数据比你开出的数组大小还要再大很多呢？该怎么办？
• 如果这个对象中只有一个字符，那你开了一个大小为1024B的空间， 剩下的1023B不是造成了很大的浪费吗？

带着上面的这些疑问，我们一起改造一下这个流提取的接口

• 首先我们确实是要先开出一个数组，数组的大小给128即可

char buf[128];
int i = 0;

• 然后还是以循环的方式去读取，在循环内部呢把每次读取到的字符放到数组中去，并使用变量i去做一个计数

while (ch != '\n')		// 以换行作为分隔符
{
	buf[i++] = ch;
	// ...
	ch = in.get();
}

• 在每次将字符存放到数组中后，我们便要去判断一下这个i是否到达了 127，若是的话就不能再继续读取了，而是要把最后的\0给手动加上，那这就算是一个完整的字符串了，追加到 string对象 中的即可，最后的话别忘了把i重置为0，继续下一组数据的读取

if (i == 127)
{
	buf[i] = '\0';
	s += buf;
	i = 0;
}

• 当跳出循环的时候，我们还要对这个【i】再去判断一下，若是这个i != 0的话，即没有到达127，只能说明这一组数据还无法追加到对象中。那我们还要再去做一个手动追加，防止数据丢失

if (i != 0)
{
	buf[i] = '\0';
	s += buf;
}

整体代码如下：

// 流提取
istream& operator>>(istream& in, string& s)
{
	s.clear();
	char ch = in.get();
	char buf[128];
	int i = 0;
	while (ch != '\n')		// 以换行作为分隔符
	{
		buf[i++] = ch;
		// 不能等到128再去判断，要为最后的\0留空间
		if (i == 127)
		{
			buf[i] = '\0';
			s += buf;
			i = 0;
		}
		ch = in.get();
	}
	// 若是有数据且不到127的话，进行倒入
	if (i != 0)
	{
		buf[i] = '\0';
		s += buf;
	}
	return in;
}

最后我们再来测试一下，发现确实扩容的次数大大减少了

难道你认为这样就完了吗？不，还有一点我们没考虑到

【第五版本】：清理字符前多余的空格

• 对比一下我们自己实现的和库里的，就可以发现存在不同之处，库里对于字符串前面的【空格】会去做处理，但是我们在流提取的逻辑中没有考虑到这一点

• 不仅如何，库里面对于【换行】这一块也会去做处理，但是呢我们实现的一敲下回车Enter就直接结束了

• 所以我们应该在读取第一个字符的时候先将【空格】或【换行】给清理掉，直接用get函数即可，它可以读取到缓冲区中的所有内容

// 处理前缓冲区前面的空格或者换行
while (ch == ' ' || ch == '\n')
{
	ch = in.get();
}

整体代码如下：

// 流提取
istream& operator>>(istream& in, string& s)
{
	s.clear();
	char ch = in.get();
	// 处理前缓冲区前面的空格或者换行
	while (ch == ' ' || ch == '\n')
	{
		ch = in.get();
	}

	char buf[128];
	int i = 0;
	while (ch != '\n')	 // 以换行作为分隔符
	{
		buf[i++] = ch;
		// 不能等到128再去判断，要为最后的\0留空间
		if (i == 127)
		{
			buf[i] = '\0';
			s += buf;
			i = 0;
		}
		ch = in.get();
	}
	// 若是有数据且不到127的话，进行倒入
	if (i != 0)
	{
		buf[i] = '\0';
		s += buf;
	}
	return in;
}

然后再去测试一下上面的两个场景，就发现什么问题了

四、写时拷贝（了解）

最后我们再来介绍一个东西叫做【写时拷贝】

1、概念理解

• 前面我们有谈到过什么是 深拷贝，而 浅拷贝 又会引发怎样的问题，这边再来回顾一下
  • 浅拷贝会导致一块空间被析构两次
  • 浅拷贝会导致一个对象修改也引发另一个对象一并修改
• 此时我们只有使用 深拷贝 才能解决问题，但是你是否有想过深拷贝所带来的代价呢？我们每去创建一个对象就进行一个深拷贝，但是呢在后面这个对象去不会去做任何的修改，那么深拷贝的意义其实没有多大，还多浪费了一块内存空间，虽然这对操作系统来说算不得什么，但若是你在长期运行这个代码所跑起来的程序时，则会造成内存枯竭💀

所以呢有人就提出了这么一个东西，叫做【写时拷贝】，全称叫做【引用计数 · 写时拷贝】

• 看到下面的图示， s2 呢是 s1 的一份临时拷贝，并且在这个地方我们使用的就是浅拷贝，二者指向的是同一块空间，此处我们会引入一个变量作为引用计数，每当构建出来一个对象的时候，计数器 + 1，所以在当 s2 拷贝完后这个计数器即为【2】
• 那么此时在析构的时候其所采用的机制便是：当一个对象去进行析构的时候，会先去看这个计数器的值是否为【1】，如果>= 1的话，说明这块空间的维护者不止它一个，那么其就不可以去释放掉这块空间，而是将计数器--，那么此时这个计数器就变成了【1】；接下去当另一个对象再去调用析构函数的时候，发现这个计数器的值是为【1】，表示现在只有它在维护这块空间，其便会去释放掉这块空间
• 那对于上面的这种机制你可以认为是 最后一个走的关灯

当然除了解决析构两次的问题，面对拷贝修改这一块它也做了一些文章

• 当我们要对一个对象中的空间做修改的时候，此时再去执行一个 深拷贝 的逻辑，重新开出一块空间来，把原本的数据拷贝过来，让其指向这块新的空间，然后就在这个新的空间中做修改。最后在将这个计数器--
• 可以看到这个机制就很好地防止了同时修改的问题

💬 那有的同学说：那反正这最后不还是要去做一个深拷贝的，直接深拷贝不就完了，有什么意义呢？

• 其实你可以认为这是编译器是在做一个【博弈】，因为在不修改的情况下我们所执行的都是 浅拷贝，那么即可能很多对象都在维护同一块空间，此时如果这几个对象都不会去做写操作的话，那其实我们就是赚的，大家都展示同一块空间的内容即可，共同维护同一块空间，无需再多的开销
• 而只有当我们对这个对象去进行写操作的时候，才去开辟出一块新的空间进行修改，随开随用，此时也不算太晚。所以只要你浅拷贝了但是不去修改我就是赚的

💬 其实读者可以这么来理解

• 如果有读者像博主一样喜欢健身的话，就可以知道一般去健身房都是需要办卡的，只有当办卡的人数到达一定量的时候，老板才是赚的，为什么呢？原因就在于很多人办了健身卡后一般很少会来，甚至是不来，那么这个时候老板一定是赚的，如果每个会员每天都来的话，这健身器材都要不够了😓
• 那么老板赌的这个【办了卡不来】和我们上面所聊【拷贝了但是不修改】是一个道理的

2、双平台对比

清楚了什么叫做【写时拷贝】，我们现在就来测试一下

首先我们现到Linux平台下去看看

  1 #include <iostream>
  2 #include <stdio.h>
  3 #include <string.h>
  4 using namespace std;
  5 
  6 int main(void)
  7 {
  8     string s1("abc");
  9     string s2(s1);
 10 
 11     printf("Show copy\n");
 12     printf("%p\n", s1.c_str());
 13     printf("%p\n", s2.c_str());
 14     cout << "-----------------" << endl;
 15 
 16     s2[0] = 'x';
 17     printf("Show modify\n");
 18     printf("%p\n", s1.c_str());
 19     printf("%p\n", s2.c_str());
 20     cout << "-----------------" << endl;                                  
 21 
 22     return 0;
 23 }

• 可以看到，一开始在拷贝完之后两块空间中的内容都是一致的，说明这是【浅拷贝】，但是呢我在修改了对象 s2 的空间后，再去打印观察的时候就发现其所维护的空间所在地址发生了变化，也就意味着在修改前它做了一个【深拷贝】
• 所以在Linux下严格执行的就是我们本模块所讲到的 写时拷贝

• 不过呢在Windows环境下的VS中，就不是这样了。我们可以看到一开始在打印的时候 对象s1 和对象s2 所维护的空间是不同的，所以在拷贝的时候就直接去做了一个【深拷贝】，而不是【浅拷贝】
• 而且在进行 写操作 之后，它们的空间并没有发生改变，还是之前所维护的那一块空间

那可能有同学就会觉得VS还是比较奇怪的，包括我们在前面对各类接口做对比的时候，VS都会去做一些比较反常的事

VS你可以把他当做是一个财大气粗的老板，下面我们再来谈一谈VS对 string对象 这一块的容量设计

• 请读者思考一下这个 对象s1 有多大

string s1("abc");
cout << sizeof(s1) << endl;

💬 可能有读者认为这个对象中一共就三个成员变量，一个指针两个无符号整数，那大小应该就是 12

size_t _size;
size_t _capacity;
char* _str;

• 但是当我们运行起来可以发现，它的大小竟然是 28

• 对于这一块而言我们就要去了解一下 string对象 的底层封装了，在【监视】窗口中我们可以看到，它是把字符串“abc”存到了一个 Buf 数组中，这个数组可容纳的大小为16个字节，虽然下面我圈起来的是【15】，是因为最后还有一个\0
• 那么这就可以解释为什么大小为 28 了，一个Buf数组16个字节，三个成员变量12个字节，那即为 28

💬 刚才说到这个 Buf数组 只能存放下16个字节的数据，但是当这个数据量变大的时候怎么办呢？

string s2("abcxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx");

• 也是通过【监视】窗口看出，这么多的数据存放到了_Ptr所指向的堆空间中去，我们知道向堆中去申请的空间都是很大的，完全就能放得过了。那就可以看到VS这个机制还是蛮不错的

总结一下：

1. 当字符串的_size < 16的时候，字符串是存放在【Buf数组】中的
2. 当字符串的_size >= 16的时候，字符串存在【_Ptr】所指向的堆空间中

五、总结与提炼

最后来总结一下本文所学习的内容

• 本文我们重点讲到的是STL中的string类，首先我们初步认识了这个类，逐个地去了解了它的一些接口函数，包括【默认成员函数】、【常见容量操作】、【访问及遍历操作】、【修改操作】、【其他字符串操作】以及【非成员函数重载】。基本上文档中的每一个接口我们都有去了解过，希望读者可以烂熟于心，常常翻阅使用
• 但仅仅是了解了这些接口后还不够，接下去我们自己去模拟实现了这个string类，去逐步实现每一个接口的功能，不仅让我们对各个接口的性质更加地了解，而且还让我们对类和对象的一些基础语法知识有了很好的巩固。望读者也能够在阅读完本文后自己试着去模拟实现一下
• 最后呢我们又拓展了一块知识点叫做【写时拷贝】，面对 浅拷贝的危害和深拷贝的资源浪费问题，编译器呢做出了这一块的优化，通过双平台的观察我们可以了解到Linux下的【gcc / g++】采取的就是这种拷贝机制

以上就是本文要介绍的所有内容，感谢您的阅读🌹🌹🌹

文章来源地址https://www.toymoban.com/news/detail-607642.html

到了这里，关于【C++】深入浅出STL之string类的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！