【C++】STL——string的使用

大家好我是沐曦希💕

---

一、STL简介

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

网上有句话说：“不懂STL，不要说你会C++”。STL是C++中的优秀作品，有了它的陪伴，许多底层的数据结构以及算法都不需要自己重新造轮子，站在前人的肩膀上，健步如飞的快速开发。

1.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)采用，可移植性好，可公开、修改甚至贩卖，从命名风格和编程 风格上看，阅读性非常高。后面的学习主要参考的就是这个版本。

2.STL的组成

3.如何学习STL

• 在线网站

cplusplus.com - The C++ Resources Network

便于查找各种接口，函数的功能，参数等信息详细列出，更适合初学者。

官方网站: cppreference.com

• 书籍

阅读C++方向优秀的书籍便于我们理解和应用C++：《C++ Primer 中文版（第 5 版）》、《STL源码剖析》

二、编码

string类是管理字符串的数组的类，因为字符串的编码的不同，所以string也是一个模板。

u16string:表示两个字节
u32string:表示四个字节

• ASCII码值

美国信息交换标准码。
ASCII码表是计算机存值和文字符号的对应关系
只有256个字符

• Unicode(万国码)

统一码是为了解决传统的字符编码方案的局限而产生的，它为每种语言中的每个字符设定了统一并且唯一的二进制编码，以满足跨语言、跨平台进行文本转换、处理的要求。

包括了utf-8,utf-16,utf-32

utf-8兼容了ASCII，utf-8使用比较普遍，也比较节省空间

• GBK字库

gbk即国标，针对中文而设计的编码。采用双字节编码。

三、string类

C语言中，字符串是以’\0’结尾的一些字符的集合，为了操作方便，C标准库中提供了一些str系列的库函数，但是这些库函数与字符串是分离开的，不太符合OOP的思想，而且底层空间需要用户自己管理，稍不留神可能还会越界访问。

基于上面这些原因，C++标准库提供了 string 类，string 类中提供了各种函数接口，比如类的六个默认成员函数、字符串插入删除、运算符重载等等，我们可以使用 string 来实例化对象，然后通过 string 的各种接口来完成对该对象的各种操作。

基本框架:

namespace std
{
	template<class T>
	class basic_string
	{
	public:
		//string成员函数
	private:
		T* _str;
		size_t _size;
		size_t capacity;
		//string的成员变量
	};
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

根据不同的编码选用不同的string(接口是差不多的)，这里我们只需重点学习string（utf-8）， 其实string 出现的时间比 STL 要早，导致string的函数参数命名方式很多与其他STL的容器不同。

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

1. 字符串是表示字符序列的类
2. 标准的字符串类提供了对此类对象的支持，其接口类似于标准字符容器的接口，但添加了专门用于操作单字节字符字符串的设计特性。
3. string类是使用char(即作为它的字符类型，使用它的默认char_traits和分配器类型(关于模板的更多信息，请参阅basic_string)。
4. string类是basic_string模板类的一个实例，它使用char来实例化basic_string模板类，并用char_traits和allocator作为basic_string的默认参数(根于更多的模板信息请参考basic_string)。
5. 注意，这个类独立于所使用的编码来处理字节:如果用来处理多字节或变长字符(如UTF-8)的序列，这个类的所有成员(如长度或大小)以及它的迭代器，将仍然按照字节(而不是实际编码的字符)来操作。

总结：

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

四、常见构造

#include
#include
using namespace std;
int main()
{
	string s1;// 构造空的string类对象s1
	cout << s1 << endl;
	string s2("hello world");// 用C格式字符串构造string类对象s2
	cout << s2 << endl;
	string s3("hello world", 2, 5);//在pos位置向后取n个
	cout << s3 << endl;
	string s4("hello world", 5);//取前n个
	cout << s4 << endl;
	string s5(10, 'c');//个数初始化
	cout << s5 << endl;
	string s6(s3);// 拷贝构造s4
	cout << s6 << endl;
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

注意：string类对象可支持直接用cin和cout进行输入和输出，这是因为重载了流插入>>和流提取<<操作符

对于s3,如果pos+n 大于前面字符串的长度

直到结束，并不会报错：

对于string::npos

它的值是-1，但是它的类型是size_t（无符号整型)，所以它的真实值是整型的最大值4294967295。

五、operator[]

返回pos位置的字符，const string类对象调用。
重载了[]，用法类似于数组，数组的[]的本质是解引用，而这里是调用函数：

char& operator[](size_t pos)//可读，返回值可修改
{
	assert(pos < _size);
	return _str[pos];
}
const char& operator[](size_t pos) const//只能读，返回值不能修改
{
	assert(pos < _size);
	return _str[pos];
}
1
2
3
4
5
6
7
8
9
10

传引用返回，可读可改。支持修改返回值：

void test_string2()
{
	string s1("1234567");
	size_t i = 0;
	for (i = 0; i < s1.size(); ++i)
	{
		cout << s1[i] << " ";
	}
	cout << endl;
	for (i = 0; i < s1.size(); ++i)
	{
		s1[i] += 1;
	}
	cout << s1 << endl;
	//反转
	size_t begin = 0;
	size_t end = s1.size() - 1;
	while (begin < end)
	{
		swap(s1[begin++], s1[end--]);
	}
	cout << s1 << endl;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

六、iterator迭代器

迭代器行为上像指针，但是却不一定是指针。比如list中迭代器不是指针

typedef char* iterator
1

迭代器作用:

迭代器的意义在于通用，所有容器都可以使用迭代器这种方式去进行遍历和修改。而对于string类，[]足矣

1.正向迭代器

end()返回的迭代器指向的是字符串末尾的’\0’

void test_string3()
{
	string s1("123456");
	string::iterator it = s1.begin();
	while (it != s1.end())
	{
		cout << *it << " ";
		++it;
	}
	cout << endl;
	it = s1.begin();
	while (it != s1.end())
	{
		*it += 1;
		++it;
	}
	cout << s1 << endl;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

2.反向迭代器

void test_string4()
{
	string s1("123456");
	string::reverse_iterator it = s1.rbegin();
	while (it != s1.rend())
	{
		*it += 1;
		++it;
	}
	cout << s1 << endl;
}
1
2
3
4
5
6
7
8
9
10
11

3.const迭代器

const迭代器只能读，不能写，适于const对象使用；其他用法和非const迭代器。

void test_string5()
{
	string s("123456");
	string::const_iterator it1 = s.begin();
	while (it1 != s.end())
	{
		cout << *it1 << " ";
		++it1;
	}
	cout << endl;
	string::const_reverse_iterator it2 = s.rbegin();
	while (it2 != s.rend())
	{
		cout << *it2 << " ";
		++it2;
	}
	cout << endl;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

为此，C++11特意区别了普通迭代器和const迭代器提供了下面的接口，作为区分：

七、Capacity容量操作

1.接口

void test_string6()
{
	string s("hello world!");
	cout << s.size() << endl;//12
	cout << s.length() << endl;//12
	cout << s.capacity() << endl;//15
	cout << s << endl;
	// 将s中的字符串清空，注意清空时只是将size清0，不改变底层空间的大小
	s.clear();
	cout << s.size() << endl;//0
	cout << s.capacity() << endl;//15

	// 将s中有效字符个数增加到10个，多出位置用'a'进行填充
	// “aaaaaaaaaa”
	s.resize(10, 'a');
	cout << s << endl;
	cout << s.size() << endl;//10
	cout << s.capacity() << endl;//15
	// 将s中有效字符个数增加到15个，多出位置用缺省值'\0'进行填充
	// "aaaaaaaaaa\0\0\0\0\0"
	s.resize(15);
	cout << s << endl;
	cout << s.size() << endl;//15
	cout << s.capacity() << endl;//15
	// 注意此时s中有效字符个数已经增加到15个
	s.resize(16, 'x');
	cout << s.size() << endl;//16
	cout << s.capacity() << endl;//31,超过15，扩容
	cout << s << endl;
	// 将s中有效字符个数缩小到5个
	s.resize(5);
	cout << s.size() << endl;//5
	cout << s.capacity() << endl;//15
	cout << s << endl;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

size()和length()两个接口的底层是一样的，都是获得size的大小。这里推荐使用size()，方便后期的接口一致。

2.扩容

在VS2022下查看扩容:

void TestPushBack()
{
	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';
		}
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

在g++下：

但是，扩容也会有开销，如果我们提前知道要开多少，就可以使用reserve（）：

注意：

1. size()与length()方法底层实现原理完全相同，引入size()的原因是为了与其他容器的接口保持一致，一般情况下基本都是用size()。
2. clear()只是将string中有效字符清空，不改变底层空间大小。
3. resize(size_t n) 与 resize(size_t n, char c)都是将字符串中有效字符个数改变到n个，不同的是当字符个数增多时：resize(n)用0来填充多出的元素空间，resize(size_t n, char c)用字符c来填充多出的元素空间。注意：resize在改变元素个数时，如果是将元素个数增多，可能会改变底层容量的大小，如果是将元素个数减少，底层空间总大小不变。
4. reserve(size_t res_arg=0)：为string预留空间，不改变有效元素个数，当reserve的参数小于string的底层空间总大小时，reserver不会改变容量大小。

八、Modifiers修改操作

#include
#include
using namespace std;
void test_string1()
{
	string s1("hello");//用"hello"构造s1
	s1.push_back(' ');//在s1后插入一个字符' '
	s1.append("world");//在s1后追加一个字符串"world"
	s1 += 'C'; // 在s1后追加一个字符'C'
	s1 += "PP"; // 在s1后追加一个字符串"PP"
	cout << s1 << endl;
	cout << s1.c_str() << endl; // 以C语言的方式打印字符串
}
int main()
{
	test_string1();
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

#include
#include
#include
#include
using namespace std;
void test_string1()
{
	string s1("hello world");
	//insert
	s1.insert(0, "lj ");
	cout << s1 << endl;
	s1.insert(9, "lj");
	cout << s1 << endl;
	//erasse
	s1.erase(9, 3);
	cout << s1 << endl;
	s1.erase(0, 4);
	cout << s1 << endl;
	s1.erase(5, 30);
	cout << s1 << endl;
}
void test_string2()
{
	string s1("hello world hello world");
	string s2("hello world hello world");
	string s3("we are family");
	string s4(s3);
	//assign
	s1.assign("hehehe", 5);
	cout << s1 << endl;
	//replace
	s2.replace(6, 5, "lj");
	cout << s2 << endl;

	//find与replace的结合使用
	size_t pos = s3.find(' ');
	while (pos != string::npos)
	{
		s3.replace(pos, 1, "%20");
		pos = s3.find(' ', pos + 3);
	}
	cout << s3 << endl;
	//+=的使用
	string ret;
	for (auto ch : s4)
	{
		if (ch != ' ')
		{
			ret += ch;
		}
		else
		{
			ret += "%20";
		}
	}
	cout << ret << endl;
}
//c_str
void test_string3()
{
	string file("test.cpp");
	FILE* fout = fopen(file.c_str(), "r");
	assert(fout);
	char ch = fgetc(fout);
	while (ch != EOF)
	{
		cout << ch;
		ch = fgetc(fout);
	}
	fclose(fout);
}
int main()
{
	test_string1();
	//test_string2();
	//test_string3();
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78

#include
#include
using namespace std;
void test_string1()
{
	//要求取文件名后缀
	//Test.cpp
	//Test.cpp.zip.tar
	string file;
	cin >> file;
	size_t pos = file.rfind('.');//倒着找
	if (pos != string::npos)
	{
		string sub = file.substr(pos);
		cout << sub << endl;
	}
}
int main()
{
	test_string1();
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

注意：

1. 在string尾部追加字符时，s.push_back© / s.append(1, c) / s += 'c’三种的实现方式差不多，一般情况下string类的+=操作用的比较多，+=操作不仅可以连接单个字符，还可以连接字符串。
2. 对string操作时，如果能够大概预估到放多少字符，可以先通过reserve把空间预留好。

九、非成员函数重载

对于流插入和流提取都是以空格、换行作为结束标志的（scanf也是）。

#include
#include
using namespace std;
void test_string1()
{
	string s1;
	cin >> s1;
	cout << s1 << endl;
	scanf("%s", &s1);
	cout << s1 << endl;
}
int main()
{
	test_string1();
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

为了解决这个问题，我们可以采用getline

遇到’\n’结束