【C++】STL介绍 + string类使用介绍 + 模拟实现string类

目录

前言

一、STL简介

二、string类

1.为什么学习string类

2.标准库中的string类

3.auto和范围for

4.迭代器

5.string类的常用接口说明

三、模拟实现 string类

前言

本文带大家入坑STL，学习第一个容器string。

一、STL简介

在学习C++数据结构和算法前，我们需要先了解C++的STL，方便后续学习其他数据结构

1.什么是STL?

STL(standard template libaray-标准模板库)：是C++标准库的重要组成部分，不仅是一个可复用的组件库，而且是一个包罗数据结构与算法的软件框架。

2.STL的版本

原始版本：Alexander Stepanov、Meng Lee 在惠普实验室完成的原始版本，本着开源精神，他们声明允许任何人任意运用、拷贝、修改、传播、商业使用这些代码，无需付费。唯一的条件就是也需要向原始版本一样做开源使用。 HP 版本--所有STL实现版本的始祖。
P. J. 版本：由P. J. Plauger开发，继承自HP版本，被Windows Visual C++采用，不能公开或修改，缺陷：可读性比较低，符号命名比较怪异。
RW版本：由Rouge Wage公司开发，继承自HP版本，被C++ Builder 采用，不能公开或修改，可读性一般。
SGI版本：由Silicon Graphics Computer Systems，Inc公司开发，继承自HP版本。被GCC(Linux)采用，可移植性好，可公开、修改甚至贩卖，从命名风格和编程风格上看，阅读性非常高。我们后面学习STL要阅读部分源代码，主要参考的就是这个版本。

3.STL的六大组件

以上内容后续都会了解到，总之我们要明白STL的重要性。STL在C++的笔试和面试中占比很大，在工作上更是“不懂STL，不要说你会C++”。STL是C++中的优秀作品，有了它的陪伴，许多底层的数据结构以及算法都不需要自己重新造轮子，站在前人的肩膀上，健步如飞的快速开发。

二、string类

1.为什么学习string类

原字符串的缺陷：C语言中，字符串是以'\0'结尾的一些字符的集合，为了操作方便，C标准库中提供了一些str系列的库函数，但是这些库函数与字符串是分离开的，不太符合OOP的思想（封装、继承和多态），而且底层空间需要用户自己管理，稍不留神可能还会越界访问。
实用性：在OJ中，有关字符串的题目基本以string类的形式出现，而且在常规工作中，为了简单、方便、快捷，基本都使用string类，很少有人去使用C库中的字符串操作函数。

2.标准库中的string类

在使用string类时，必须包含#include <string>头文件，平时学习可使用using namespace std;展开命名空间方便使用

#include <iostream>
#include <string>
using namespace std;

int main()
{
	string s1("hello world");//定义对象s1并初始化
	cout << s1 << endl;//打印输出

	return 0;
}

简单说明下命名空间std 与 头文件 还有 STL 之间的联系：

命名空间std 是C++标准库的命名空间，也就是C++编程的重要组成部分，它不仅包含了STL的所有组件，也包括了更多的东西。例如输入输出流（cin,cout）、容器（string,vector,list,map等）、迭代器、智能指针、内存管理工具、算法等
所以我们平时使用库函数和容器等，如果不使用using namespace std;展开这个命名空间的话，就需要在前面指定命名空间std::。
头文件的包含，比如<iostream>和<strintg>，你实际上是在告诉编译器你想要使用该头文件中定义的功能，这些功能都是 std 这个命名空间的一部分，因此可以说，我们是通过包含不同的头文件来解锁和访问 std 命名空间中不同部分的内容。
不过需要注意的是，C++语言本身不仅仅是由 std 命名空间组成。C++的核心内容还包括：语言语法、基础数据类型、内存模型和管理、面向对象编程特性、模版和泛型编程、异常处理。
切记，关键字不是 std 中定义的，C++关键字是语言本身的一部分，它们不是由标准库提供的，而是直接由编译器识别的。

继续了解string类

其实严格意义上，string不属于容器，在下图容器分类中就没有看到string

这是因为string在STL之前就已经有了，因为在设计上与STL中容器很相似，因此就有串这么一个数据结构，后面使用方法中就可以看出 string 设计的方法非常冗余，因为要照顾旧方法同时又要融入STL。

基础串

string类其实是一个类模版，它的原模版就叫 basic_string（基础串）

在基础串模版中，后两个参数有默认的模版参数，string 的定义中给基础串的第一个参数传递了 char 并进行了重命名，所以我们创建 string 模版类时没有给定模版参数

当然，除了经常使用的 string 类外，还有另外两个不同的string类：

这两个不同的string类，一个是一个字符占2个字节，另一个是4个字节，这里大小不同的原因是因为编码不同。编码在下文学习完string的使用后会讲到。这里主要是讲为什么要搞一个基础串的模版，原因就在这里。

不管怎样，我们最常用的还是前面的string，主要因为它兼容的编码多。

深入学习string前先学习两个语法糖

3.auto和范围for

1. auto关键字

#include <iostream>
using namespace std;

int main()
{
	int a = 1;
	auto b = a;//根据表达式右边自动推导出b的类型
	cout << b << endl;
	cout << sizeof(b) << endl;

	return 0;
}

运行结果：

auto使用注意事项：（C++11）

在早期C/C++中auto的含义是：使用auto修饰的变量，是具有自动存储器的局部变量，后来这个不重要了。C++11中，标准委员会变废为宝赋予了auto全新的含义即：auto不再是一个存储类型指示符，而是作为一个新的类型指示符来指示编译器，auto声明的变量必须由编译器在编译时期推导而得。
用auto声明指针类型时，用auto和auto*没有任何区别，但用auto声明引用类型时则必须加&
当在同一行声明多个变量时，这些变量必须是相同的类型，否则编译器将会报错，因为编译器实际只对第一个类型进行推导，然后用推导出来的类型定义其他变量。
auto不能作为函数的参数，可以做返回值（c++11支持），但是建议谨慎使用。
补充：c++20开始，支持 auto 作为函数参数类型
auto不能直接用来声明数组

例如：

（1）推导指针类型

#include <iostream>
using namespace std;

int main()
{
	//自动推导指针
	int a = 10;
	auto b = &a;
	cout << b << endl << &a << endl;

	return 0;
}

运行结果：

（2）推导引用类型

#include <iostream>
using namespace std;

int main()
{
	//引用类型推导
	int a = 10;
	int& b = a;
	auto& c = b;
	cout << &a << endl;
	cout << &c << endl << endl;

	//不加&推导出来的不是引用类型，而是原数据类型
	auto d = b;
	cout << &d << endl;

	return 0;
}

运行结果：

（3）可做函数返回值，但不能做参数

//auto做返回值
auto func1()
{
	int a = 10;
	return a;
}

//auto做参数
//报错：error C3533: 参数不能为包含“auto”的类型
//int func2(auto x)
//{
//	int a = x;
//	return a;
//}

但auto作为返回值有时候会是个坑，因为如果代码复杂，维护时会导致无法快速判断该函数返回值，写了函数注释还好，没写就会大大增加代码维护成本，所以慎用。

2.范围for

语法：

for(类型 e : 容器)

{

//每循环一次e自动指向下一个数据

//直到容器遍历完成

}

#include <iostream>
#include <string>
using namespace std;

int main()
{
	//范围for用于遍历容器
	string s1("hello world");
	for (char c : s1)
	{
		cout << c << " ";
	}
	cout << endl;

	//可配合auto使用
	//如果想改变容器内容，需要使用引用类型
	for (auto& c : s1)
	{
		++c;
	}
	cout << s1 << endl;

	return 0;
}

运行结果：

范围for用处总结：

对于一个有范围的集合而言，由程序员来说明循环的范围是多余的，有时候还会容易犯错误。因此 C++11 中引入了基于范围的for循环。for循环后的括号由冒号“ ：”分为两部分：第一部分是范围内用于迭代的变量，第二部分则表示被迭代的范围，自动迭代，自动取数据，自动判断结束。
范围for可以作用到数组和容器对象上进行遍历
范围for的底层很简单，容器遍历实际就是替换为迭代器，这个从汇编层也可以看到。

4.迭代器

迭代器，STL六大组件之一，关于迭代器的介绍，C++迭代器是一种用于遍历容器（如数组、链表、向量等）中元素的工具。它们提供了统一的接口，使得不同类型的容器可以以相似的方式进行访问和操作。
我们现阶段可以先理解迭代器为一种指针，但本质上不是指针，我们先学会使用

常见迭代器：

iterator
常量迭代器 const_iterator
反向迭代器 reverse_iterator
常量反向迭代器 const_reverse_iterator

声明迭代器时，一般是 std::容器名(如果是模版需要模版参数):: iterator 对象名。

展开了命名空间std就可省略，因为不同容器迭代器底层实现不同，因此需要指定容器

例如：利用迭代器遍历string

#include <iostream>
#include <string>
using namespace std;

int main()
{
	string s1("hello world");

	//迭代器遍历
	string::iterator it = s1.begin();
	while (it != s1.end())
	{
		cout << *it << " ";
		++it;
	}
	cout << endl;

	return 0;
}

运行结果：

解释：

首先 string类的接口 begin()和end()：

我们发现，它们的返回值就是迭代器，它们的作用就是返回容器的头部与尾部的迭代器，对于string来说，end()指向的就是'\0'，begin()指向的就是下标为0的字符。

在使用上，用法和指针相似：

使用*运算符解引用迭代器以访问它所指向的元素。
使用->运算符访问指向的对象的成员（如果该对象是一个类或结构体）。
可以使用++或--来前进或后退迭代器。

注意：判断迭代器是否走到容器的结尾是使用 != 容器.end() 来判断，而不是其他关系判断，另外，一般使用while循环遍历，for循环虽然也行，但写法上相较复杂点。

迭代器的全部接口：

r开头的就是支持反向迭代器，c开头的就是就是常量迭代器，但是前面我们注意到了，begin 和 end 都有重载const版本的，在 rbegin 和 rend 中一样都有重载 const 版本的（注意，这种成员函数重载是根据 const 区分的，不是参数）。因此，我们一般不使用c开头的以及cr开头的迭代器接口。

rend() 指向的是第一个元素前一个位置
rbegin() 指向的是最后一个元素的位置，对于string来说，就是'\0'前一个字符
因为倒着遍历还是从 rbegin 开始，一直到 != rend() 结束，因此这种安排合理

剩余三种迭代器遍历演示：

#include <iostream>
#include <string>
using namespace std;

int main()
{
	//1.反向迭代器
	string s1("hello world");
	string::reverse_iterator rit = s1.rbegin();
	while (rit != s1.rend())
	{
		cout << *rit << " ";
		++rit;
	}
	cout << endl;

	//2.const迭代器
	const string s2("hello world");//string::const_iterator cit = s1.begin();
	auto cit = s2.begin();//使用前面所学的auto自动识别类型更加方便
	while (cit != s2.end())
	{
		cout << *cit << " ";
		++cit;
	}
	cout << endl;

	//3.const反向迭代器
	auto crit = s2.rbegin();
	while (crit != s2.rend())
	{
		cout << *crit << " ";
		++crit;
	}
	cout << endl;

	return 0;
}

运行结果：

需要注意的是：反向迭代器虽是倒着遍历，但依旧是使用++使迭代器指向下一个元素。因为对于反向迭代器来说，它正方向就是从右往左。

另外，迭代器与指针类似，当然也可以修改非const容器对象的内容

#include <iostream>
#include <string>
using namespace std;

int main()
{
	string s1("hello world");
	auto it = s1.begin();
	while (it != s1.end())
	{
		++(*it);
		++it;
	}
	cout << s1 << endl;

	return 0;
}

运行结果：

小结：

迭代器的是所有的STL容器通用的一种元素访问方式，不同的容器，迭代器底层会有些不同，但是用法是一样的，因此学好迭代器很重要

5.string类的常用接口说明

强调，C++为了适配C语言，因此 string 类对象的末尾也是存在 '\0' 的

1.string类的常见构造

上图中：

（1）就是不传参的默认构造
（2）就是拷贝构造
（3）从string对象 str 的 pos(下标) 位置开始，拷贝 len（默认 nops）个字符进行构造
（4）使用字符串进行构造
（5）使用字符串 s 的前 n 个字符进行构造
（6）用 n 个相同字符 c 进行构造
（7）使用迭代器进行构造

下面演示一下（3）（4）（5）（6）（7）

#include <iostream>
#include <string>
using namespace std;

int main()
{
	string s1("hello world");//使用字符串初始化构造
	cout << "s1：" << s1 << endl;

	string s2(s1, 6, 5);//利用string对象的下标+长度进行构造
	cout << "s2：" << s2 << endl;

	string s3("xxxxxxxxxxxx", 4);//使用字符串的前4个字符进行构造
	cout << "s3：" << s3 << endl;

	string s4(5, 'y');//用n个相同字符进行构造
	cout << "s4：" << s4 << endl;

	string s5(s1.begin(), s1.end() - 5);//利用迭代器进行构造
	cout << "s2：" << s5 << endl;

	return 0;
}

运行结果：

赋值运算符重载：

演示：

#include <iostream>
#include <string>
using namespace std;

int main()
{
	string s1("111");
	string s2("222");

	//(1)
	s1 = s2;
	cout << s1 << endl;

	//(2)
	s1 = "333";
	cout << s1 << endl;

	//(3)
	s1 = '*';
	cout << s1 << endl;

	return 0;
}

运行结果：

补充：npos和析构

（1）npos

npos 是 string 类的一个静态成员变量，无符号整形并且等于-1，因此就是整形的最大值（2进制位全是1），常用作缺省参数，表示最大值。

（2）string 类的析构

类的析构函数会在对象作用域结束时自动调用，用于销毁对象

2.string类对象的容量操作

函数名称	简要功能说明
size	返回字符串有效字符长度
length	返回字符串有效字符长度
max_size	返回字符串可以达到的最大长度。
resize	将有效字符的个数该成n个，多出的空间用字符c填充
capacity	返回空间总大小
reserve	为字符串预开辟空间
clear	清空有效字符
empty	检测字符串释放为空串，是返回true，否则返回false
shrink_to_fit	缩容，减小字符串容量以适应其大小

（1）size和length

size和length的功能相同，都是返回字符串有效字符个数，而这样设计的原因是历史原因导致的，主要就是STL出来之前，string已经存在了。为了保留原string接口，同时为了和STL其余容器保持通用性，因此设计了size，其余STL容器都是size返回有效元素个数。对于string，我们平时也基本是使用size，而不是length。

演示：

（2）max_size

这个用处不大，编译器也开不了这么大的空间。

演示：（64位）

（3）capacity

返回空间容量，无需多言

演示：

（4）resize

将字符串大小调整为 n 个字符的长度，那么这里就有3中情况：

如果 n 小于当前字符串长度，则当前值将缩短为其前 n 个字符，并删除第 n 个字符以外的字符。
如果 n 大于当前字符串长度却又小于当前空间容量，则将当前字符串大小调整为 n，指定了c，则新元素将初始化为 c ，未指定则初始化为'\0'
如果 n 大于当前空间容量，则需要扩容，然后初始化新元素，新元素处理同上

演示：

#include <iostream>
#include <string>
using namespace std;

int main()
{
	string s1("11111111111111111111");
	cout << s1 << endl;
	cout << "size: " << s1.size() << endl;
	cout << "capacity: " << s1.capacity() << endl;
	cout << endl;

	//resize
	//1.n < size
	s1.resize(10);
	cout << s1 << endl;
	cout << "size: " << s1.size() << endl;
	cout << "capacity: " << s1.capacity() << endl;
	cout << endl;

	//2.size < n < capacity
	s1.resize(25,'x');
	cout << s1 << endl;
	cout << "size: " << s1.size() << endl;
	cout << "capacity: " << s1.capacity() << endl;
	cout << endl;

	//3.n > capacity
	s1.resize(40, 'y');
	cout << s1 << endl;
	cout << "size: " << s1.size() << endl;
	cout << "capacity: " << s1.capacity() << endl;
	cout << endl;

	return 0;
}

运行结果：

（5）reserve

更改空间容量，如果 n 大于当前字符串容量，则该函数会导致容器将其容量增加到 n 个字符（或更大）。此函数对字符串长度没有影响，也无法更改其内容。因此reserve不能缩小容量，也就是 n 小于当前字符串容量，没有什么实际效果。
适用场景：提前知道大概需要多少空间，提前开辟可以避免多次扩容，提升效率。

演示：

拓展：

我们观察string类对象每次扩容的大小：

#include <iostream>
#include <string>
using namespace std;

int main()
{
	string s1;
	size_t old = s1.capacity();
	cout << "capacity: " << old << endl;

	for (size_t i = 0; i < 100; i++)
	{
		s1 += 'x';
		if (s1.capacity() != old)
		{
			cout << "capacity: " << s1.capacity() << endl;
			old = s1.capacity();
		}
	}

	return 0;
}

运行结果：

我们发现：除了第一次到第二次是2倍扩容以外，31以后就是 1.5 倍扩容了。
首先，这个底层扩容倍率每个平台是不一定一样的，以上是vs2022的结果。
然后为啥第一次不是1.5倍扩容的原因：string 底层还存在一个类似 char buff[16] 大小的字符数组，如果数据小于16的话就会存在这个数组里面，大于16就储存在堆上开的空间中。这样做是为了避免存储数据小时频繁开辟空间。所以第一次的容量 15 不算是扩容。

我们可以通过计算空间大小验证一下：（32位）

28的由来：底层字符串指针 4 字节、底层 size 和 capacity 记录大小和容量的无符号整形一共占 8 字节、剩下的 16 个字节就是 char buff[16] 数组。

我们在调试窗口中也能观察到该数组：

（5）clear

清空有效字符，对应字符串来说，就是将'\0'移动到第一位

（6）empty

判空，为空返回ture(1)，反之返回false(0)。

（7）shrink_to_fit

缩容，将容量缩小与有效字符一样大的空间，注意，该函数不是任意情况下都会进行缩容，而是当capacity 与 size 相差过大时才会缩容。

3.string类对象的访问接口

（1）operator[ ]

运算符重载函数，返回对应下标的引用（越界会直接报错）
最常用的元素访问接口

演示：

#include <iostream>
#include <string>
using namespace std;

int main()
{
	string s1("hello world");
	cout << s1[4] << endl;
	s1[4] = 'x';//因为返回的是引用类型，因此修改可直接影响原对象
	cout << s1[4] << endl;

	return 0;
}

运行结果：

配合 size()接口，可以实现遍历string类对象：

#include <iostream>
#include <string>
using namespace std;

int main()
{
	string s1("hello world");
	for (size_t i = 0; i < s1.size(); i++)
	{
		cout << s1[i] << " ";
	}
	cout << endl;

	return 0;
}

运行结果：

（2）at

at 功能大致与 operator[ ] 相同，区别是 at 访问失败会抛出异常，而 [ ] 是直接断言报错

演示：关于捕获异常的知识，我会在后续篇章中单独讲解

（3）back 和 front

back 和 front 分别是返回字符串第一个字符和最后一个字符，因为这些 [ ] 也可以轻松做到，所以这两个接口用的不多，访问元素用的最多的就是 [ ]。

演示：

4.string类对象的修改操作

函数名称	功能说明
operator+=	在字符串后追加字符或字符串
append	在字符串后追加一个字符串
push_back	尾插一个字符
assign	为字符串分配一个新值，替换其当前内容
insert	在指定位置前插入字符或字符串
erase	删除指定位置字符
replace	替换指定位置字符
swap	交换两个字符串
pop_back	尾删一个字符

（1）operator+=

我们可以直接尾插一个string类对象，或者一个字符串，或者一个字符
+= 是字符串尾插中运用最多的接口

演示：

除了+=以外，string 也重载了 + 运算符，区别就是不会修改本身，返回值为 + 的结果：

（2）push_back

尾插一个字符

演示：

（3）append

append 重载了许多函数，功能都是尾插一段字符串：

（1）尾插一个 string 类对象
（2）从待尾插 string 对象的 subpos 位置开始，尾插 sublen 个字符
（3）尾插一段字符串
（4）尾插一段字符串的前 n 个字符
（5）尾插 n 个相同的字符 c
（6）以迭代器的方式，尾插一段字符串

演示：

#include <iostream>
#include <string>
using namespace std;

int main()
{
	string s1("111");
	string s2("xxxx");
	string s3("hello world");

	//(1)
	s1.append(s2);
	cout << s1 << endl;

	//(2)
	s1.append(s3, 0, 5);
	cout << s1 << endl;

	//(3)
	s1.append("world");
	cout << s1 << endl;

	//(4)
	s1.append("yyyyyyyyyyy", 3);
	cout << s1 << endl;

	//(5)
	s1.append(2, 'a');
	cout << s1 << endl;

	//(6)
	s1.append(s3.begin() + 5, s3.end());
	cout << s1 << endl;

	return 0;
}

运行结果：

（4）insert

insert 支持头插以及中间指定位置之前插入元素，重载了很多函数，类比构造和append函数，其实不难看出每种重载函数的用法，以下不一一列举了
提醒：insert 进行头插和中间插入时，需要挪动数据，因此效率低下，不建议多次使用。

演示：

#include <iostream>
#include <string>
using namespace std;

int main()
{
	string s1("111");
	string s2("22");
	string s3("xxxxxx");
	string s4("orld");

	//(1)
	s1.insert(0, s2);
	cout << s1 << endl;

	//(2)
	s1.insert(3, s3, 0, 2);
	cout << s1 << endl;

	//(3)
	s1.insert(s1.size(), "hello");
	cout << s1 << endl;

	//(4)
	s1.insert(0, "yyyyyyyyyyyyy", 3);
	cout << s1 << endl;

	//(5)
	s1.insert(0, 4, 'm');
	cout << s1 << endl;

	//(6)
	s1.insert(s1.end(), 'w');
	cout << s1 << endl;

	//(7)
	s1.insert(s1.end(), s4.begin(), s4.end());
	cout << s1 << endl;

	return 0;
}

运行结果：

（5）erase

erase 用于删除字符：

（1）缺省参数 0 和 npos，npos前面说过是整形最大值，也就是说什么都不传，默认全部删除（效果和 clear 一样），传参则按照指定位置大小删除。
（2）删除迭代器位置的字符
（3）删除迭代器区间的字符

演示：

#include <iostream>
#include <string>
using namespace std;

int main()
{
	string s1("I want to be a C++ master");
	
	//(1)
	s1.erase(0, 1);
	cout << s1 << endl;

	//(2)
	s1.erase(s1.begin());
	cout << s1 << endl;

	//(3)
	s1.erase(s1.begin(), s1.begin() + 5);
	cout << s1 << endl;

	//(1)
	s1.erase();
	cout << s1 << endl;

	return 0;
}

运行结果：

（6）assign

该函数主要功能是对字符串进行重新赋值
相比重载的赋值运算符，功能上有重合，虽然assign更灵活，但用的更多的还是重载的赋值运算符函数。

演示：（根据前面函数的参数，很容易判断每种重载函数的功能，因此不再详细演示）

（7）replace

replace 主要功能就是替换，也提供了一大堆重载函数，我们不用一个个去记忆，需要的时候查阅就行，前面我们已经判断了很多重载函数的功能，根据参数就大致能判断出每种重载函数的用法。
另外在替换过程中，如果是平替（替换与被替换字符数相等）则效率高，如果不是平替，少替多，多替少，替换次数多了时，效率就会很低，因此除了平替或者替换次数少，不建议经常使用

演示：（只演示一个）

（8）pop_back

尾删一个字符

演示：

（9）swap

关于 swap，string类提供了一个，还有一个全局的，算法库里面也有一个，这么设计的原因是什么？

原因：

第一个 swap 是 string类的成员函数，例如两个string对象s1、s2，使用 s1.swap(s2) 即可调用到该函数完成交换，该交换是直接交换两个字符串的地址，因此效率高。
而我们平时习惯性写成 swap(s1,s2)，这样就会调用到算法库里的swap，也就是第三个swap，该swap是一个函数模版，其内部对于 string 对象来说是深拷贝，深拷贝效率没有直接交换两个字符串地址效率高。因此为了避免调用到第三个swap，就创造了第二个全局的swap函数。
第二个 swap 函数内部就是调用第一个swap，直接交换两字符串地址，因此效率比第三个swap高，第三个swap是函数模版，对于函数模版来说，有现成的就会直接使用现成的，不会再实例化一份。因此写成 swap(s1,s2)不会调用到第三个swap，而是调用第二个swap。
关于这样的设计，其它容器也是如此，都是为了方便调用到成员函数的swap。

5.string类对象的其它常见操作

函数名称	函数功能
c_str	将string类对象的数据以C语言字符串的格式返回
copy、substr	相比copy，substr用的更多，用于截取当前字符串的子串
find系列	用于查找字符或字符串
关系运算符重载、compare	因为string重载了关系运算符，所以一般很少使用compare判断两字符串关系
operator<<、operator>>	重载的流插入、流提取运算符
getline	从输入流中读取字符

（1）c_str

获取C语言格式的字符串，因为C++兼容C语言，所以有时候需要混合编程，但是C语言中关于字符串的库函数是不支持string类对象的，因此使用该函数就能解决这些问题

演示：

#define _CRT_SECURE_NO_WARNINGS 1
#include <iostream>
#include <string>
using namespace std;

int main()
{
	//C++使用C语言的文件操作
	string s1("test.cpp");
	FILE* pf = fopen(s1.c_str(), "r");//c_str返回C格式的字符串
	char ch = fgetc(pf);
	while (ch != EOF)
	{
		cout << ch;
		ch = fgetc(pf);
	}
	cout << endl;

	return 0;
}

运行结果：

（2）substr

返回当前字符串 pos 位置开始，len 长的子串。
因为都有缺省参数，所以默认返回整个字符串

演示：

#include <iostream>
#include <string>
using namespace std;

int main()
{
	string s1("****hello world****");
	string s2 = s1.substr(4, 11);
	cout << s2 << endl;

	return 0;
}

运行结果：

（3）find系列

1. find

第一个参数 str、s、c 就是需要查找的字符串或字符
参数 pos 是查找的起始位置，默认0则从头开始找
第三个重载函数的参数 n 是指定需查找的字符串 s 的长度
find 查找成功会返回匹配的第一个字符的下标，查找失败则返回 string::npos

演示：

#include <iostream>
#include <string>
using namespace std;

int main()
{
	//将下面字符串的空格全部替换为 '#' 号
	string s1("There are two needles in this haystack with needles.");
	size_t pos = s1.find(' ');
	while (pos != string::npos)
	{
		s1[pos] = '#';
		pos = s1.find(' ', pos + 1);
	}
	cout << s1 << endl;

	return 0;
}

运行结果：

2.rfind

rfind 就是倒着找，其他的和 find 一样
适用于找后缀的场景

演示：

#include <iostream>
#include <string>
using namespace std;

int main()
{
	//指出下面文件的后缀名
	string s1("test.cpp.zip");
	size_t pos = s1.rfind('.');

	cout << s1.substr(pos) << endl;

	return 0;
}

运行结果：

3.find_first_of

作用：在字符串中搜索与其参数中指定的任何字符匹配的第一个字符
简单点说：find是查找单一字符或字符串，find_first_of是查找一个集合，只要查找的字符串中出现了这个集合中的字符，那么它就会返回该下标
成功返回下标，失败返回 string::npos

演示：

#include <iostream>
#include <string>
using namespace std;

int main()
{
	//屏蔽5个元音字母
	string s1("qwertyuiopasdfghjklzxcvbnm");
	size_t pos = s1.find_first_of("aeiou");
	while (pos != string::npos)
	{
		s1[pos] = '*';
		pos = s1.find_first_of("aeiou", pos + 1);
	}
	cout << s1 << endl;

	return 0;
}

运行结果：

4.find_first_not_of

该函数与 find_first_not_of 相反，它是找出所有不在匹配串中的字符位置

演示：

#include <iostream>
#include <string>
using namespace std;

int main()
{
	//屏蔽5个元音字母以外的字母
	string s1("qwertyuiopasdfghjklzxcvbnm");
	size_t pos = s1.find_first_not_of("aeiou");
	while (pos != string::npos)
	{
		s1[pos] = '*';
		pos = s1.find_first_not_of("aeiou", pos + 1);
	}
	cout << s1 << endl;

	return 0;
}

运行结果：

5.find_last_of 与 find_last_not_of

相比 find_first_of 和 find_first_not_of，区别就是倒着找，这里不再赘述和演示

（4）关系运算符重载

注意是全局函数，不是成员函数
模拟时会详细说明

（5）operator<<、operator>>

模拟时会详细说明

（6）getline

解决流提取时，无法读取空格和换行符等问题
参数 delim 是自定义读取结束符，不传参默认读到换行符结束

你是否遇到以下困扰？cin流提取时遇到空格或者换行符会自动截断，导致赋值不完整。

而getline就是专门解决这个问题的：

三、模拟实现 string类

了解完string类的使用，接下来就是自己模拟实现出string类

为了避免太复杂，我们不使用模版实现，还是按照声明和定义分离的方式来实现string类，模拟实现的意义是让我们对string的使用更加深刻，不是完全的模拟实现，主要是对常用的接口的模拟实现。

1.string.h 头文件

#pragma once
#define _CRT_SECURE_NO_WARNINGS 1
#include <iostream>
#include <cassert>
using namespace std;

//为避免与std中的string冲突，因此定义一个命名空间分隔
namespace txp
{
	class string
	{
	public:
		//定义迭代器
		using iterator = char*;
		using const_iterator = const char*;
	
		//声明构造，拷贝构造
		string(const char* str = "");
		string(const string& s);

		//赋值运算符重载
		string& operator=(string s);

		//声明析构函数
		~string();

		//对于一些简短的函数，直接在头文件中定义，较长的函数则放到定义文件中
		//定义c_str成员函数
		const char* c_str() const
		{
			return _str;
		}

		//定义size成员函数
		size_t size() const
		{
			return _size;
		}

		//定义重载运算符[]
		char& operator[](size_t i)
		{
			assert(i < _size);

			return _str[i];
		}

		//const版本 []
		const char& operator[](size_t i) const
		{
			assert(i < _size);

			return _str[i];
		}

		//定义迭代器接口begin
		iterator begin()
		{
			return _str;
		}

		//迭代器接口end
		iterator end()
		{
			return _str + _size;
		}

		//const版本的begin
		const_iterator begin() const
		{
			return _str;
		}

		//const版本的end
		const_iterator end() const
		{
			return _str + _size;
		}

		//定义clear成员函数
		void clear()
		{
			_str[0] = '\n';
			_size = 0;
		}

		//声明reserve函数
		void reserve(size_t n);

		//声明push_back函数
		void push_back(char ch);

		//声明append函数
		void append(const char* str);

		//声明运算符重载函数+=
		string& operator+=(char ch);

		//声明第二个版本的+=
		string& operator+=(const char* str);

		//声明insert成员函数
		void insert(size_t pos, char ch);

		//声明重载的insert成员函数
		void insert(size_t pos, const char* str);

		//声明erase成员函数
		void erase(size_t pos, size_t len = npos);

		//声明find成员函数
		size_t find(char ch, size_t pos = 0) const;
		size_t find(const char* str, size_t pos = 0) const;

		//声明substr成员函数
		string substr(size_t pos = 0, size_t len = npos) const;

		//声明swap成员函数
		void swap(string& str);

	private:
		//底层结构
		char* _str = nullptr;
		size_t _size = 0;
		size_t _capacity = 0;
	public:
		//声明静态成员变量npos
		static const size_t npos;
	};

	//声明关系运算符重载函数
	bool operator==(const string& s1, const string& s2);
	bool operator!=(const string& s1, const string& s2);
	bool operator>(const string& s1, const string& s2);
	bool operator<(const string& s1, const string& s2);
	bool operator>=(const string& s1, const string& s2);
	bool operator<=(const string& s1, const string& s2);

	//声明流插入、流提取运算符重载函数，以及getline函数
	ostream& operator<<(ostream& os, const string& str);
	istream& operator>>(istream& is, string& str);
	istream& getline(istream& is, string& str, char delim = '\n');

	//声明全局的swap函数
	void swap(string& s1, string& s2);
}

2.string.cpp 文件

因函数之间存在复用关系，因此大家直接看注释吧

#include "string.h"

namespace txp
{
	//定义全局静态变量npos
	const size_t string::npos = -1;

	//默认构造，注意只能在声明处给缺省值，因此定义时没有写缺省值
	string::string(const char* str)
		:_size(strlen(str))
	{
		_capacity = _size;
		_str = new char[_size + 1];//多开辟一个空间用于存储'\0'
		strcpy(_str, str);
	}

	//拷贝构造
	//1.传统写法：自己开空间+自己拷贝
	/*string::string(const string& s)
	{
		_str = new char[s._capacity + 1];
		strcpy(_str, s._str);
		_size = s._size;
		_capacity = s._capacity;
	}*/

	//2.现代写法：利用构造开空间+利用swap拷贝
	string::string(const string& s)
	{
		string tmp(s._str);//创建临时对象tmp用于拷贝s的_str进行构造
		swap(tmp);//交换后，this指向的对象就是拷贝构造出来的对象，而tmp出了函数就会被析构
	}

	//赋值运算符重载
	//1.传统写法
	/*string& string::operator=(const string& s)
	{
		if (this != &s)
		{
			delete[] _str;
			_str = new char[s._capacity + 1];
			strcpy(_str, s._str);
			_capacity = s._capacity;
			_size = s._size;
		}

		return *this;
	}*/

	//2.现代写法：
	string& string::operator=(string s)//利用传值传参进行拷贝构造
	{
		swap(s);//再进行交换，原this指向的空间就由s析构带走了
		return *this;
	}

	//注意：现代写法没有效率提升，只是更简洁了，本质是一种复用


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

	//reserve开空间，只考虑扩容的情况
	void string::reserve(size_t n)
	{
		if (n > _capacity)
		{
			char* tmp = new char[n + 1];
			strcpy(tmp, _str);
			delete[] _str;
			_str = tmp;
			_capacity = n;
		}
	}

	//尾插字符
	void string::push_back(char ch)
	{
		/*if (_size == _capacity)
		{
			reserve(_capacity == 0 ? 4 : _capacity * 2);
		}
		_str[_size++] = ch;*/

		insert(_size, ch);//当我们实现insert后，可以直接复用来实现push_back的效果
	}

	//尾插字符串
	void string::append(const char* str)
	{
		/*size_t len = strlen(str);
		if ((_size + len) > _capacity)
		{
			size_t newCapacity = 2 * _capacity;
			if ((len + _size) > newCapacity)
			{
				newCapacity = len + _size;
			}
			reserve(newCapacity);
		}
		strcpy(_str + _size, str);
		_size += len;*/

		insert(_size, str);//可直接复用insert
	}

	//重载运算符+=
	string& string::operator+=(char ch)
	{
		push_back(ch);//复用push_back即可
		return *this;
	}

	//重载版本
	string& string::operator+=(const char* str)
	{
		append(str);//复用append即可
		return *this;
	}

	//insert插入
	void string::insert(size_t pos, char ch)
	{
		assert(pos <= _size);

		//需扩容时按照2倍扩容
		if (_size == _capacity)
		{
			reserve(_capacity == 0 ? 4 : _capacity * 2);
		}

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

		//插入
		_str[pos] = ch;
		++_size;
	}

	//insert重载
	void string::insert(size_t pos, const char* str)
	{
		assert(pos <= _size);

		//由于不确定插入的字符串大小，因此扩容时需进行2次判断
		size_t len = strlen(str);
		if ((_size + len) > _capacity)
		{
			size_t newCapacity = 2 * _capacity;
			if ((len + _size) > newCapacity)//2倍扩容不够，就需要多少开多少
			{
				newCapacity = len + _size;
			}
			reserve(newCapacity);
		}

		//挪动数据
		size_t end = _size + len;
		//对于字符串来说，停止条件不能写成end>pos，会导致越界，pos+len是最后一次挪动的位置
		//因此要保证end = pos+len时继续挪动，所以停止条件为end > (pos+len-1)
		while (end > (pos + len - 1))
		{
			_str[end] = _str[end - len];
			--end;
		}

		//插入
		for (size_t i = 0; i < len; i++)
		{
			_str[pos + i] = str[i];
		}

		_size += len;
	}

	//删除
	void string::erase(size_t pos, size_t len)
	{
		assert(pos < _size);
		//第一种情况，要删除的字符数大于剩余的字符，直接挪动'\0'所在位置即可
		if (len >= (_size - pos))
		{
			_str[pos] = '\0';
			_size = pos;
		}
		else//剩下的情况就是要手动挪动剩余数据了
		{
			size_t end = pos + len;
			while (end <= _size)
			{
				_str[end - len] = _str[end];//从后向前挪
				++end;
			}

			_size -= len;
		}
	}

	//查找
	size_t string::find(char ch, size_t pos) const
	{
		assert(pos < _size);

		for (size_t i = pos; i < _size; i++)
		{
			if (_str[i] == ch)
			{
				return i;
			}
		}

		return npos;
	}
	//字符串查找算法有很多，我们直接使用C库里的函数strstr
	size_t string::find(const char* str, size_t pos) const
	{
		assert(pos < _size);

		const char* ptr = strstr(_str + pos, str);
		if (ptr == nullptr)
		{
			return npos;
		}
		else
		{
			return ptr - _str;
		}
	}

	//取子串
	string string::substr(size_t pos, size_t len) const
	{
		assert(pos < _size);

		//len大于剩余串长度，则直接取到结尾
		if (len > (_size - pos))
		{
			len = _size - pos;
		}

		txp::string sub;
		sub.reserve(len);
		for (size_t i = 0; i < len; i++)
		{
			sub += _str[pos + i];
		}
		return sub;
	}

	//交换
	void string::swap(string& str)
	{
		//调用算法库中的swap即可
		std::swap(_str, str._str);
		std::swap(_size, str._size);
		std::swap(_capacity, str._capacity);
	}

	//关系运算符重载
	bool operator==(const string& s1, const string& s2)
	{
		return strcmp(s1.c_str(), s2.c_str()) == 0;//直接利用C的库函数
	}
	bool operator!=(const string& s1, const string& s2)
	{
		return !(s1 == s2);//复用==
	}
	bool operator>(const string& s1, const string& s2)
	{
		return strcmp(s1.c_str(), s2.c_str()) > 0;//利用C库
	}
	bool operator<(const string& s1, const string& s2)
	{
		return strcmp(s1.c_str(), s2.c_str()) < 0;//利用C库
	}
	bool operator>=(const string& s1, const string& s2)
	{
		return s1 > s2 || s1 == s2;//复用>和==
	}
	bool operator<=(const string& s1, const string& s2)
	{
		return s1 < s2 || s1 == s2;//复用<和==
	}

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

		return os;
	}

    //流提取
	istream& operator>>(istream& is, string& str)
	{
		str.clear();//先清空数据
		int i = 0;
		char buff[256];//为避免多次扩容，选择创建一个buff数组
		char ch;

		//传统的流提取会忽略掉空格和换行符，怎么解决呢？
		ch = is.get();//get为istream类对象的一个接口，可以读取任意字符
		while (ch != ' ' && ch != '\n')
		{
			buff[i++] = ch;
			//当buff数组存满时就+=到str
			if (i == 255)
			{
				buff[i] = '\0';
				i = 0;
				str += buff;
			}

			ch = is.get();
		}
		//如果buff中还有剩余字符未处理
		if (i > 0)
		{
			buff[i] = '\0';
			str += buff;
		}

		return is;
	}

	//定义getline函数
	istream& getline(istream& is, string& str, char delim)
	{
		str.clear();
		int i = 0;
		char buff[256];
		char ch;

		ch = is.get();
		while (ch != delim)//与流提取的差别就是这里，delim控制结束符
		{
			buff[i++] = ch;

			if (i == 255)
			{
				buff[i] = '\0';
				i = 0;
				str += buff;
			}

			ch = is.get();
		}
		if (i > 0)
		{
			buff[i] = '\0';
			str += buff;
		}

		return is;
	}

	//全局交换
	void swap(string& s1, string& s2)
	{
		//调用成员函数的swap即可
		s1.swap(s2);
	}
}