C++string类

一、为什么要学习string类？

1.1 C语言中的字符串

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

二、标准库中的string类型

2.1 string类

(string类的文档介绍：String)
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_string<char,char_traits, allocator> string;
4.不能操作多字节或者变长字符的序列。

2.2 string类的常用接口说明(下面只讲解最常用的接口)

(1) string类对象的常见构造

void Teststring()
{
	string s1; //构造空的string类对象s1
	string s2("hello bit"); //用C格式字符串构造string类对象s2
	string s3(s2); //拷贝构造s3
}

(2) string类对象的容量操作

🔥注意:
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不会改变容量大小。

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

(4) string类对象的修改操作

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

上面的几个接口大家了解一下，下面的OJ题目中会有一些体现他们的使用。string类中还有一些其他的操作，这里不再一一列举，大家在需要用到时不明白了查文档即可。
(6) vs和g++下string结构的说明
注意: 下述结构是在32位平台下进行验证的，32位平台下指针占4个字节。
○ vs下string的结构
string总共占28个字节，内部结构稍微复杂一点，先是有一个联合体，联合体用来定义string中字符串的存储空间:
■ 当字符串长度小于16时，使用内部固定的字符数组来存放
■ 当字符串长度大于等于16时，从堆上开辟空间

union _Bxty
{ 
    //storage for small buffer or pointer to larger one
    value_type _Buf[_BUF_SIZE];
    pointer _Ptr;
    char _Alias[_BUF_SIZE]; //to permit aliasing
} _Bx;

这种设计也是有一定道理的，大多数情况下字符串的长度都小于16，那string对象创建好之后，内部已经有了16个字符数组的固定空间，不需要通过堆创建，效率高。
其次: 还有一个size_t字段保存字符串长度，一个size_t字段保存从堆上开辟空间总的容量
最后: 还有一个指针做一些其他事情。
故总共占16+4+4+4=28个字节:
○ g++下string的结构
G++下，string是通过写时拷贝实现的，string对象总共占4个字节，内部只包含了一个指针，该指针将用来指向一块堆空间，内部包含了如下字段:
■ 空间总大小
■ 字符串有效长度
■ 引用计数

struct _Rep_base
{
	size_type _M_length;
	size_type _M_capacity;
	_Atomic_word _M_refcount;
};

■ 指向堆空间的指针，用来存储字符串

(string类的成员函数使用及其相关操作：StringTest)

三、string类的模拟实现

3.1 经典的string类问题

上面已经对string类进行了简单的介绍，大家只要能够正常使用即可。在面试中，面试官总喜欢让学生自己来模拟实现string类，最主要是实现string类的构造、拷贝构造、赋值运算符重载以及析构函数。先看下面string类的实现是否有问题?

// 为了和标准库的string区分,此处使用String
class String
{
public:
	/*
	String()
	    :_str(new char[1])
	{*_str = '\0';}
	*/

	//String(const char* str = "\0")  //错误示范
	//String(const char* str = nullptr)  //错误示范
	String(const char* str = "")
	{
		// 构造String类对象时,如果传递nullptr指针,可以认为程序非法
		if (nullptr == str)
		{
			assert(false);
			return;
		}
		_str = new char[strlen(str) + 1];  //多加的1是留给\0的空间
		strcpy(_str, str); //将str指向空间的字符串拷贝给_str
	}
	~String()
	{
		if (_str != nullptr)
		{
			delete[] _str;
			_str = nullptr;
		}
	}
private:
	char* _str;
};
// 测试
int main()
{
	String s1("hello world!");
	String s2(s1);
	
	return 0;
}

可以在监视窗口看一下两个对象的_str所指向的空间是否一样：
说明: 上述string类没有显式定义其拷贝构造函数与赋值运算符重载，此时编译器会合成默认的。当用s1构造s2时，编译器会调用默认的拷贝构造。最终导致的问题是：s1、s2共用同一块内存空间，在释放时同一块空间被释放多次而引起程序崩溃! 这种拷贝方式，称为浅拷贝。

3.2 浅拷贝

浅拷贝: 也称位拷贝，编译器只是将对象中的值拷贝过来。如果对象中管理资源，最后就会导致多个对象共享同一份资源，当一个对象销毁时就会将该资源释放掉，而此时另一些对象不知道该资源已经被释放，以为还有效，所以当继续对资源进项操作时，就会发生发生了访问违规。

就像一个家庭中有两个孩子，但父母只买了一份玩具，两个孩子愿意一块玩，则万事大吉，万一不想分享就你争我夺，玩具损坏。
可以采用深拷贝解决浅拷贝问题，即: 每个对象都有一份独立的资源，不要和其他对象共享。父母给每个孩子都买一份玩具，各自玩各自的就不会有问题了。

3.3 深拷贝

如果一个类中涉及到资源的管理，其拷贝构造函数、赋值运算符重载以及析构函数必须要显式给出。一般情况都是按照深拷贝方式提供。

3.4 传统版写法的String类

3.4.1 拷贝构造的传统写法

//s2(s1):用s1去拷贝构造s2(this是s2,s是s1)
// 1.拷贝构造传统写法
string(const string& s)
{
	_str = new char[s._capacity + 1];
	strcpy(_str, s._str);
	_size = s._size;
	_capacity = s._capacity;
}

上面可以看到拷贝构造函数的传统写法中：先为要创建的对象new一个空间，其空间大小与用来拷贝构造它的对象的空间大小相同。多加的1是为’\0’字符开的空间。然后将s对象空间里的内容拷贝到要创建的对象中，有效数据个数与空间容量也要和s的一样。

3.4.2 拷贝构造的现代写法

void swap(string& s)
{
	std::swap(_str, s._str);
	std::swap(_size, s._size);
	std::swap(_capacity, s._capacity);
}
//拷贝构造
string(const string& s)
	:_str(nullptr)
	,_size(0)
	,_capacity(0)
{
	string tmp(s._str);
	swap(tmp);
}

现代写法中，其实就是调构造函数来完成拷贝构造的：

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

现代写法好处不仅在于简化，而且可以发现在拷贝构造中创建的临时对象tmp，在与要创建的对象交换其内容以后，临时对象tmp在函数调用完后会自动调用析构函数析构掉。

3.5 模拟实现string类的size、capacity的、[]重载

模拟实现string类的成员函数size()、capacity()、[]运算符重载：

size_t size() const
{
	return _size;
}
size_t capacity() const 
{
	return _capacity;
}
//能读能写
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()返回字符串的长度(不包括\0)，以字节为单位。capacity()返回当前为字符串分配的存储空间的大小，以字节表示。(数组的下标是从0开始的，即size()的返回值表示字符串中的字符个数，也是结束标志\0的下标)

3.6 模拟实现string类的reserve、resize

void reserve(size_t n)
{
	if (n > _capacity)
	{
		char* tmp = new char[n + 1];
		strcpy(tmp, _str);
		delete[] _str;
		_str = tmp;
		_capacity = n;
	}
}

reserve函数是用来扩容的，如果所给参数n大于现在对象的_capacity就会进行扩容。索性我们就根据所给参数n开辟一块空间tmp，其中加1是为给\0留一个空间，将当前对象的_str的内容拷贝给tmp。释放_str，再让_str指向tmp指向的内容，空间容量capacity改为n。出了函数以后，局部指针变量tmp会销毁掉。

void resize(size_t n, char ch = '\0')
{
	if (n < _size)
	{
		_str[n] = '\0';
		_size = n;
	}
	else
	{
		reserve(n);
		while (_size < n)
		{
			_str[_size] = ch;
			_size++;
		}
		_str[_size] = '\0';
	}
}

resize是用来改变对象的_size的，如果所给参数n小于_size的话，就会进行数据的删减，直接将n下标置的元素置为\0，然后把_size改为n即可。如果n大于_size的话，先检查是否要扩容，然后可以根据所给参数ch来填充满有效数据个数，然后将n下标位置的数据置为\0。注意：n既是有效数据个数，也是最后一个数据的下一个位置的下标。

3.7 模拟实现string类的push_back、append、+=重载

//尾插一个字符
void push_back(char ch)
{
	if (_size == _capacity)
	{
		reserve(_capacity == 0 ? 4 : _capacity * 2);
	}
	_str[_size] = ch;
	++_size;
	_str[_size] = '\0';
}
//追加一个字符
void append(const char* str)
{
	size_t len = strlen(str);
	if (_size + len > _capacity)
	{
		reserve(_size + len);
	}
	strcpy(_str + _size, str);
	_size += len;
}
string& operator+=(char ch)
{
	push_back(ch);
	return *this;
}
string& operator+=(const char* str)
{
	append(str);
	return *this;
}

1.push_back函数是用来给一个对象的字符串尾插一个字符的。尾插前要先检查空间是否已满，若满了就要进行扩容，然后再将字符ch尾插到字符串后面，然后_size要增加1，并且要将_size下标的数据置为\0。
2.append函数是用来给字符串后面尾插一个字符串的。尾插也要先检查空间是否已满，然后才将要尾插的字符串插入进行，相应的_size也要加上尾插的字符串长度。
3.比起上面的两个函数，用+=来实现字符或者字符串的尾插显得更通俗易懂。所以推荐使用+=来尾插字符或字符串。

3.8 =重载

//s2 = s1:将s1赋值给s2(s2是this,s1是str),其中s1和s2是已经创建存在的对象
// 1.赋值传统写法
string& operator=(const string& str)
{
	if (this != &str)
	{
		char* tmp = new char[str._capacity + 1];
		strcpy(tmp, str._str);
		delete[] _str;
		_str = tmp;
		_size = str._size;
		_capacity = str._capacity;
	}
	return *this;
}
// 2.赋值现代写法Ⅰ
string& operator=(const string& str)
{
	if (this != &str)
	{
		string tmp(str);
		swap(tmp);
	}
	return *this;
}
// 3.赋值现代写法Ⅱ
string& operator=(string tmp)
{
	swap(tmp);
	return *this;
}

赋值运算符重载，即实现将一个对象赋值给另一个对象。注意：赋值是两个已经创建存在的对象进行赋值。赋值也是要采用深拷贝，上面赋值的现代写法，会调用拷贝构造来完成对一个临时对象的构造，然后让改临时对象与当前要被赋值的对象进行内容交换。这样写的好处不仅是简化了代码，而且tmp这个临时对象由于与被赋值的对象进行了内容交换。那么在函数调用完毕后，会销毁这个临时对象，也就将原来被赋值的对象的内容给释放掉了，一举两得。

3.9 模拟实现string类的insert、erase

void insert(size_t pos,char ch)
{
	assert(pos <= _size);
	if (_size == _capacity)
	{
		reserve(_capacity == 0 ? 4 : _capacity * 2);
	}
	size_t end = _size + 1; //'\0'的后一个位置
	while (end > pos)
	{
		_str[end] = _str[end - 1];
		end--;
	}
	_str[pos] = ch;
	_size++;
}
void insert(size_t pos, const char* str)
{
	assert(pos <= _size);
	size_t len = strlen(str);
	if (_size + len > _capacity)
	{
		reserve(_size + len);
	}
	//挪动数据
	size_t end = size() + 1;
	while (end > pos)
	{
		_str[end + len - 1] = _str[end-1];
		--end;
	}
	strncpy(_str + pos, str, len);
	_size += len;
}
void erase(size_t pos, size_t len = npos)
{
	assert(pos < _size);
	if (len == npos || pos + len >= _size)
	{
		_str[pos] = '\0';
		_size -= len;
	}
	else
	{
		size_t begin = pos + len;
		while (begin <= _size)
		{
			_str[begin - len] = _str[begin];
			begin++;
		}
		_size -= len;
	}
}

1.insert即在指定的pos位置插入一个字符或字符串。只要涉及插入数据就要提前检查空间是否已满，在指定位置插入字符或字符串，要把数据往后挪，挪完后才能插入数据。记得插入数据以后，还要确保字符串的结束标志\0在有效数据最后。
2.erase是用来删除字符串中的指定字符个数的。从pos位置开始往后删除len个字符，需要考虑要删除的len数量是否超过了字符串的有效数据个数。

🔥🔥🔥由于insert、erase都涉及数据的挪动，效率比较低下，所以实际中能不用他们就尽量不用。

3.10 模拟实现string类的find、substr

size_t find(char ch, size_t pos = 0)
{
	assert(pos < _size);
	for (size_t i = pos; i < _size; i++)
	{
		if (_str[i] == ch)
			return i;
	}
	return npos;
}
size_t find(const char* sub)
{
	char* p = strstr(_str, sub);
	if (p != nullptr)
	{
		return p - _str;
	}
	else
	{
		return npos;
	}
}
string substr(size_t pos, size_t len = npos)
{
	assert(pos < _size);
	string s;
	size_t end = pos + len;
	if (len == npos || pos + len >= _size)
	{
		len = _size - pos;
		end = _size;
	}

	s.reserve(len);
	for (size_t i = pos; i < end; i++)
	{
		s += _str[i];
	}
	return s;
}

1.find用于在一个字符串中查找指定的字符或字符串。如果找到了就返回该字符或字符串的下标位置(从左往右第一次出现的位置)。
2.substr用于返回一个字符串中的一个子串(深拷贝)，一般和find配合起来使用。返回pos位置开始往后的len个字符。（substr返回一个新构造的字符串对象，其值初始化为此对象的子字符串的副本)

3.11 模拟实现string类的迭代器iterator、<<、>>重载

3.11.1 C++中什么是迭代器？

🔥在C++中，迭代器(lterator)是用于访问和遍历容器(如vector、list、map等)元素的核心工具，其本质是一个类似指针的对象，但提供了更统一的抽象接口，能够屏蔽不同容器的底层实现细节。

(1) 迭代器的核心特性

1.功能定义
迭代器通过指针式的操作(如递增、解引用等)访问容器元素，通常支持以下基本操作:
● 指向容器中的元素(类似指针)。
● 通过++或 – 移动位置(支持单向或双向移动，取决于迭代器类型)。
● 通过*操作符访问或修改元素值。
2.核心作用
● 统一访问方式: 允许以相同语法操作不同容器(如数组、链表)，简化了代码复杂度。
● 与算法结合: 作为STL算法的桥梁，如sort()、find()等算法通过迭代器操作容器。

(2) 迭代器的分类
根据支持的操作能力，迭代器可分为以下类型(按功能由弱到强排序)

1. 输入迭代器(lnput lterator)
   仅支持单向遍历和读取元素(如istream_iterator)。
2. 输出迭代器 (Output lterator)
   仅支持单向遍历和写入元素(如 ostream_iterator)。
3. 前向迭代器(Forward lterator)
   支持多次读写和单向遍历(如单链表 forward_list 的迭代器)。
4. 双向迭代器(Bidirectional lterator)
   支持双向移动(如list、map的迭代器)。
5. 随机访问迭代器(Random Access lterator)
   支持常数时间的跳跃访问(如vector、deque的迭代器)。

string类的迭代器实现如下：

typedef char* iterator;
typedef const char* const_iterator;
//迭代器(左闭右开):像指针一样的东西,但不一定是指针
iterator begin()
{
	return _str;
}
iterator end()
{
	return _str + _size;
}
const_iterator begin() const
{
	return _str;
}
const_iterator end() const
{
	return _str + _size;
}
//清理字符串
void clear()
{
	_str[0] = '\0';
	_size = 0;
}
ostream& operator<<(ostream& out, const string& s)
{
	for (auto ch : s)
	{
		cout << ch;
	}

	return out;
}
istream& operator>>(istream& in, string& s)
{
	s.clear();
	char buff[129];
	size_t i = 0;
	char ch = in.get(); //get()用来从键盘上读取一个字符,包括空格、换行
	while (ch !=' ' && ch != '\n')
	{
		buff[i++] = ch;
		if (i == 128)
		{
			buff[i] = '\0';
			s += buff;
			i = 0;
		}
		ch = in.get();
	}
	if (i != 0)
	{
		buff[i] = '\0';
		s += buff;
	}

	return in;
}

1.对于string类对象的流插入操作符重载，需要注意只是要答应对象中字符串的每个字符，所以不能改变传给operator<<函数的参数s，所以要用const修饰，并且采用传引用的方式更高效。由于形参s是被const修饰的对象，所以迭代器也要有const修饰的iterator。范围for的底层就是迭代器。
2.string类对象的流提取操作符重载需要注意：如果原对象中还存储着字符串，则要先将字符串给清理掉，然后才从键盘上输入字符串。输入字符串当遇到空格、换行就提取结束。由于cin读取字符时，读不到空格，所以库里提供了一个get()函数可以读取到空格、换行字符。上面先创建一个了字符数组buff，暂时用来存储读取到的字符，当buff数组存储满了以后再将数组的内容尾插到s中，再从buff的起始位置开始继续存储读取的字符。这样做的好处是能减少扩容。而且buff是一个局部的数组，出了函数作用域就会被销毁。

🕯以上只是string类的部分接口的模拟实现，没有全部讲解。所以有需要指定的接口时，可以去官网查询使用。
(string类的模拟实现：SimulateString)

3.12 写时拷贝(了解)

写时拷贝就是一种拖延症，是在浅拷贝的基础之上增加了引用计数的方式来实现的。

🍓引用计数: 用来记录资源使用者的个数。在构造时，将资源的计数给成1，每增加一个对象使用该资源时，就给计数增加1，当某个对象被销毁时，先给该计数减1，然后再检査是否需要释放资源，如果计数为1，说明该对象是资源的最后一个使用者，那就将该资源释放; 否则就不能释放，因为还有其他对象在使用该资源。