C++STL——string类详解及其模拟实现

头文件<string>

我们先来看看string类是如何被声明的：

typedef basic_string<char> string;

可以看到：

string类是被类模板basic_string用数据类型char实例化后得到的一个具体的类的别名

同时规定：

• string类是一个用来表示字符串的类
• 标准string类提供的接口和许多标准容器的接口类似，但也额外提供了处理单字节字符的接口（处理字符串的常规操作）
• 不能用来操作多字节或者变长字节的字符序列

需要注意：

string类是包含在C++标准库中的，因此如果要使用string：

• 一种方式：使用域作用限定符，例如std::string。
• 另一种方式：使用using namespace std打开命名空间

string类的构造函数string()被重载成了许多形式，但我们只需掌握以下三种即可：

string();	//方法一：构造一个空串
string (const string& str);		//方法二：拷贝构造
string (const char* s);		//方法三：用一个常量字符串构造

例如：

#include <string>
#include <iostream>

nt main()
{
	std::string s1;	
	std::string s2("hello world");
	std::string s3(s2);

    //string类里面重载了流插入<<和流提取>>运算符
	std::cout << "字符串s1为：" << s1 << std::endl;
	std::cout << "字符串s2为：" << s2 << std::endl;
	std::cout << "字符串s3为：" << s3 << std::endl;

	return 0;
}

output:

字符串s1为：
字符串s2为：hello world
字符串s3为：hello world

string& operator= (const string& str);	//类类型之间的赋值
string& operator= (const char* s);	//利用隐式类型转换，先将字符串s实例化为一个string类型对象，再进行赋值
string& operator= (char c);		//和第二种方法类似

例如：

#include <string>
#include <iostream>

int main()
{
	std::string s1, s2, s3;

	s1 = "hello world";
	s2 = 'c';
	s3 = s1;

	std::cout << "字符串s1为：" << s1 << std::endl;
	std::cout << "字符串s2为：" << s2 << std::endl;
	std::cout << "字符串s3为：" << s3 << std::endl;

	return 0;
}

output:

字符串s1为：hello world
字符串s2为：c
字符串s3为：hello world

size_t size() const;
size_t length() const;

• 这两个函数的效果是一模一样的
• 但是更建议使用函数size()
• 字符串的有效长度是不包括结束字符‘\0’的，其结果就和C语言的strlen()函数一样

例如：

#include <string>
#include <iostream>

int main()
{
	std::string s1;
	std::string s2("hello world");

	std::cout << "sizs of s1: " << s1.size() << std::endl;
	std::cout << "sizs of s2: " << s2.size() << std::endl;

	return 0;
}

output:

sizs of s1: 0
sizs of s2: 11

size_t capacity() const;

• 一般来说，这个最大容量同样指的是可以存放有效字符的最大容量，也不包括结束符‘\0’

需要注意，由于不同平台所用的库不同，因此当用同一个字符串构造string对象时，分配给其用来存储字符的初始空间也不一定相同（即capacity不一定相同），例如：

对于相同的代码：

#include <string>
#include <iostream>

int main()
{
	std::string s1;
	std::string s2("nice to meet you");

	std::cout << "capacity of s1 is: " << s1.capacity() << std::endl;
	std::cout << "capacity of s2 is: " << s2.capacity() << std::endl;

	return 0;
}

在VS下，output：

capacity of s1 is: 15
capacity of s2 is: 31

在Linux下，output:

capacity of s1 is: 0
capacity of s2 is: 16

• 实际上，这两个平台的扩容机制也完全不同，之后我们会进行演示

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

      char& at (size_t pos);
const char& at (size_t pos) const;

相同点：

• 和普通的字符数组一样，string类类型的对象也可以通过类似[下标]的方式获得指定位置的字符
• 这个函数被重载成了两份，分别给非cosnt对象和const对象使用

不同点：

• 如果传入的pos大于size()，那么对于operator []，则会直接报错
• 而对于at()，则会抛出异常

有了这两个成员函数，我们就可以对string对象存储的数据进行遍历访问了：

#include <string>
#include <iostream>

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

	for (int i = 0; i < s1.size(); i++)
		std::cout << s1[i] << ' ';
	std::cout << std::endl;

	for (int i = 0; i < s1.size(); i++)
		std::cout << s1.at(i) << ' ';
	std::cout << std::endl;

	return 0;
}

output:

h e l l o   w o r l d
h e l l o   w o r l d

      iterator begin();
const_iterator begin() const;
/*****************************************/
      iterator end();
const_iterator end() const;

• begin()即返回一个指向字符序列第一个字符的迭代器；end()即返回一个指向字符序列**最后一个字符（即‘\0’）**的迭代器
• 而begin() const和end() const则是针对const对象做出的函数重载

注意：

由于string类实际上就是存储字符序列的类，因此针对它的迭代器iterator，我们可以将其看成为一个指向char类型的指针char*；而const_iterator则对应的是const char*

• 有些小伙伴可能会疑惑：为什么const_iterator不写成const iterator
• 首先我们要清楚对于const对象，其返回的迭代器应该具有这样的功能：允许访问（遍历）数据，但不允许修改数据
• 而const iterator本质上修饰的是迭代器iterator本身，我们可以看作是char* const，这样子的效果是不能改变迭代器指向，但是可以改变迭代器指向数据的内容，这显然是不符合要求的
• 但**const_iterator本质上修饰的就是迭代器指向的数据**，我们可以看作是const char*，这样就可以符合要求

示例：

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

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

	string::iterator it = s1.begin();

    //对每个字符进行+1操作再进行打印
	while (it != s1.end())
	{
		(*it)++;
		cout << *it << ' ';
		it++;
	}
	cout << endl;

	return 0;
}

output:

i f m m p ! x p s m e

      reverse_iterator rbegin();
const_reverse_iterator rbegin() const;
/*****************************************/
      reverse_iterator rend();
const_reverse_iterator rend() const;

• 和begin()/end()类似，只是返回的是反向迭代器
• 所谓的反向迭代器即rbegin()返回一个指向字符序列最后一个有效字符的迭代器；rend()返回一个指向字符序列**第一个字符之前的字符（被认为是反向末端）**的迭代器
• 如果反向迭代器的指向可以修改，那么例如对于rbegin()的返回结果进行+1操作，就会使迭代器指向倒数第二个字符
• 反向迭代器和正向迭代器的返回类型原理类似，故不作赘述

例如：

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

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

	string::reverse_iterator it = s1.rbegin();
	while (it != s1.rend())
	{
        cout << *it << ' ';
		it++;
	}
	cout << endl;

	return 0;
}

output:

d l r o w   o l l e h

void reserve (size_t n = 0);

• reserve成员函数会将string的最大容量capacity扩展为n
• 需要注意，由于不同平台依赖的库不同，所以reserve最终的效果也会不同，但是无论如何，reserve()绝不会影响到存储的数据

下面就来看看在VS和Linux两个平台上reserve()函数的不同之处：

对于同样一份代码：

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

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

	cout << "the capacity of s1 is " << s1.capacity() << endl;
	s1.reserve(100);
	cout << "after reserve(100), the capacity of s1 is " << s1.capacity() << endl;
	s1.reserve(50);
	cout << "after reserve(50), the capacity of s1 is " << s1.capacity() << endl << endl;

	cout << "the capacity of s2 is " << s2.capacity() << endl;
	s2.reserve(1);
	cout << "after reserve(1), the capacity of s2 is " << s2.capacity() << endl;

	return 0;
}

VS：

output:

the capacity of s1 is 15
after reserve(100), the capacity of s1 is 111
after reserve(50), the capacity of s1 is 111

the capacity of s2 is 15
after reserve(1), the capacity of s2 is 15

Linux：

output:

the capacity of s1 is 11
after reserve(100), the capacity of s1 is 100
after reserve(50), the capacity of s1 is 50

the capacity of s2 is 11
after reserve(1), the capacity of s2 is 11

可以总结出二者的不同：

• VS分配空间时，总会比给定值多几个空间；而Linux则是给多少开多少
• VS的reserve()函数不能缩小空间，只能扩大空间；而Linux的reserve函数可以缩小空间

同时它们也有一个共同点：

• 无论给定值再怎么小，reserve()都不会影响到原来的数据

void resize (size_t n);
void resize (size_t n, char c);

• resize()函数也是对最大容量的管理。但是它既可以缩小容量，同时也能影响到原有数据
• 同时，这个函数还有初始化的功能：
  • 如果传入的n大于size小于capacity，那么如果字符c被指明，那么剩余的空间就会被字符c填充；如果字符c没被指明，那么剩余的空间就会被空字符‘\0’填充
  • 如果传入的n大于capacity，那么就会在扩容之后进行跟上面一样的初始化（填充）操作

例如：

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

int main()
{
	string s1("hello");
	string s2 = s1;

	cout << "the capacity of s1 is " << s1.capacity() << endl;
	s1.resize(s1.capacity(), 'c');
	cout << s1 << endl << endl;

	cout << "the capacity of s2 is " << s2.capacity() << endl;
	s2.resize(100);
	cout << s2 << endl;
	cout << "the capacity of s2 is " << s2.capacity() << endl;
	cout << "the size of s2 is " << s2.size() << endl;

	return 0;
}

output:

the capacity of s1 is 15
hellocccccccccc

the capacity of s2 is 15
hello
the capacity of s2 is 111
the size of s2 is 100

注：本篇只讲最常用的string添加字符/字符串的方法。其他方法还有如

• 👉append

• 👉push_back

• 👉insert

string& operator+= (const string& str);
string& operator+= (const char* s);
string& operator+= (char c);

例如：

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

int main()
{
	string s1;
	string s2;
	string s3;

	s1 += "hello world";
	s2 += s1;
	s3 += 'c';

	cout << s1 << endl;
	cout << s2 << endl;
	cout << s3 << endl;

	return 0;
}

output:

hello world
hello world
c

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

• 即删除从pos位置开始的len个字符

• 注意：npos为string里面定义的一个const静态全局变量

  const static size_t npos = -1;
  

• 无符号整形npos的值为-1，因此它的实际值为unsigned int的最大值

• 如果npos用来表示一个长度，那么它通常用来说明直到字符串的尾

• 如果npos用来表示一个返回值，那么它通常用来说明没有找到目标

例如：

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

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

	s1.erase(2, 2);
	cout << s1 << endl;

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

	return 0;
}

output:

heo world
h

注：本篇只讲述最常用的find和rfind。其他方法还有如：

• 👉find_first_of
• 👉find_last_of
• 👉find_first_not_of
• 👉find_last_not_of

size_t find (const string& str, size_t pos = 0) const;
size_t find (const char* s, size_t pos = 0) const;
size_t find (char c, size_t pos = 0) const;

• 即从pos位置开始，寻找目标出现的下标

• rfind()和find()使用类似，故不作赘述

例如：

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

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

	size_t pos1 = s1.find("ld");
	size_t pos2 = s1.find("l", 6);
	size_t pos3 = s1.find("nice");
	size_t pos4 = s1.rfind("!");

	cout << "pos1 =  " << pos1 << endl;
	cout << "pos2 =  " << pos2 << endl;
	cout << "pos3 =  " << pos3 << endl;
	cout << "pos4 =  " << pos4 << endl;

	return 0;
}

output:

pos1 =  9
pos2 =  9
pos3 =  4294967295
pos4 =  14

const char* c_str() const;

例如：

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

int main()
{
	string s1("hello world");
	const char* str = s1.c_str();

	cout << str << endl;

	return 0;
}

output:

hello world

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

• 获得从pos位置开始，长度为len的子串
• 同时将这个子串存储到string类中并进行返回

例如：

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

int main()
{
	string s1("hello world");
	string s2 = s1.substr(0, 5);	//hello
	string s3 = s1.substr(5);		//world
	
	cout << s2 << s3 << endl;

	return 0;
}

output:

hello world

• 有了<<流插入运算符重载，我们就可以利用std::cout来向屏幕打印string存储的字符序列
• 有了>>流提取运算符重载，我们就可以用std::cin向string类的数据
• 注意：
  • cin类似于C语言的scanf，如果碰到空白字符就会停止读取。因此cin只能用于读取不带空格的字符序列。
  • 原来的数据会被输入端新字符给覆盖
  • 如果输入的字符长度大于capacity，那么就会对这个string对象进行扩容，直到可以存储输入的字符序列。

例如：

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

int main()
{
	string s1, s2;

	cin >> s1;
	cin >> s2;

	cout << "s1 = " << s1 << endl;
	cout << "s2 = " << s2 << endl;

	return 0;
}

input:

hello
nice to meet you

output:

s1 = hello
s2 = nice

istream& getline (istream& is, string& str);

• 同样是从标准输入流向string对象输入数据
• 原来的数据会被输入端新字符给覆盖
• getline()类似于C语言的gets()，只有遇到换行才会停止读取。因此可以读取带空格的字符序列
• 如果输入的字符长度大于capacity，那么就会对这个string对象进行扩容，直到可以存储输入的字符序列。

例如：

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

int main()
{
	string s1;
	getline(cin, s1);

	cout << s1 << endl;

	return 0;
}

output:

hello world

(1)	

bool operator== (const string& lhs, const string& rhs);
bool operator== (const char*   lhs, const string& rhs);
bool operator== (const string& lhs, const char*   rhs);

(2)	

bool operator!= (const string& lhs, const string& rhs);
bool operator!= (const char*   lhs, const string& rhs);
bool operator!= (const string& lhs, const char*   rhs);

(3)	

bool operator<  (const string& lhs, const string& rhs);
bool operator<  (const char*   lhs, const string& rhs);
bool operator<  (const string& lhs, const char*   rhs);

(4)	

bool operator<= (const string& lhs, const string& rhs);
bool operator<= (const char*   lhs, const string& rhs);
bool operator<= (const string& lhs, const char*   rhs);

(5)	

bool operator>  (const string& lhs, const string& rhs);
bool operator>  (const char*   lhs, const string& rhs);
bool operator>  (const string& lhs, const char*   rhs);

(6)	

bool operator>= (const string& lhs, const string& rhs);
bool operator>= (const char*   lhs, const string& rhs);
bool operator>= (const string& lhs, const char*   rhs);

• C++string类关系运算符的逻辑与C语言字符串比较函数strcmp的逻辑类似，故不再赘述