【C++语言】string 类

一、为什么要学习 string 类

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

二、标准库中的 string 类

2.1 string 类（了解）

1. 字符串是表示字符序列的类
2. 标准的字符串提供了对此类对象的支持，其接口类似于标准字符容器的接口，但是添加了专门用于操作单字节字符串的设计特性
3. string 类是使用 char（即作为他的字符类型，使用他的默认 char_traits 和分配器类型）
4. string 类是 basic_string 模版类的一个实例，他使用 char 来实例化 basic_string 模版类，并用 char_traits 和 allocator 作为 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 类的常用接口说明

2.2.1 string 类对象的常见构造

（constructor）函数名称	功能说明
string()（重点）	构造空的string类对象，即空字符串
string(const char* s)（重点）	用C-string来构造string类对象
string(size_t n, char c)	string类对象中包含n个字符c
string(const string& s)（重点）	拷贝构造函数

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

2.2.2 string 类对象的容量操作

函数名称	功能说明
size（重点）	返回字符串有效字符长度
length	返回字符串有效字符长度
capacity	返回空间总大小
empty（重点）	检测字符串是否为空串，是，返回true；不是，返回false
clear（重点）	清空有效数据
reserve（重点）	为字符串预留空间
resize（重点）	将有效字符的个数改为n个，多出的空间用字符c填充

注意：

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不会改变容量大小 

2.2.3 string 类对象的访问以及遍历操作

函数名称	功能说明
operator[]（重点）	返回 pos 位置的字符，const string 类对象调用
begin + end	begin 获取一个字符的迭代器 + end 获取最后一个字符的迭代器
rbegin + rend	rend 获取一个字符的迭代器 + rbegin 获取最后一个字符的迭代器
范围 for	C++11 支持更简洁的范围for的新遍历方式

2.2.4 string 类对象的修改操作

函数名称	功能说明
push_back	在字符串末尾插入字符c
append	在字符串后追加一个字符串
operator +=（重点）	在字符串后追加字符串str
c_str（重点）	返回c格式的字符串
find + npos（重点）	从字符串 pos 位置开始往后找字符c，返回该字符在字符串中的位置
rfind	从字符串 pos 位置开始往前找字符c，返回该字符在字符串中的位置
substr	在 str 中从 pos 位置开始，截取 n 个字符，然后将其返回

注意：

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

2.2.5 string 类对象的非成员函数

函数名称	功能说明
operator+	尽量少用，因为传值返回，导致深拷贝效率低
operator>>（重点）	输入运算符重载
operator<<（重点）	输出运算符重载
getline（重点）	获取一行字符串
relational operators（重点）	大小比较

2.2.6 vs 和 g++ 下 string 结构的说明

注意：下述结构是在32位平台下进行验证的，32位平台下指针占4个字节 

2.2.6.1 vs下的string结构

       string 总共占28个字节，内部结构稍微复杂一点，先是有一个联合体，俩呢体用来定义 string 中字符串的存储空间：

• 当字符串长度小于16时，使用内部固定的字符数组来存放
• 当字符串长度大于等于16时，从堆上开辟空间

union _Bxty
{    // storage for small buffer or pointer to larger onevalue_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个字节。

2.2.6.2 g++下的string结构 

       g++下，string是通过写时拷贝实现的，string对象总共占4个字节，内部只包含了一个指针，该指针将来指向一块堆空间，内部包含了如下字段：

• 空间总大小
• 字符串有效长度
• 引用计数
• 指向堆空间的指针，用来存储字符串 

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

三、string 类的模拟实现

3.1 经典的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];strcpy(_str, str);}~String(){if (_str){delete[] _str;_str = nullptr;}}
private:char* _str;
};// 测试
void TestString()
{String s1("hello bit!!!");String s2(s1);
}

说明：上述的string类没有显示定义其拷贝构造函数与赋值运算符重载，此时编译器会合成默认的，当使用 s1 构造 s2 时，编译器会调用默认的拷贝构造。最终导致的问题是：s1 和 s2 共用同一块内存空间，在释放时同一块空间被释放多次而引起程序崩溃，这种拷贝方式称为浅拷贝。 

3.2 深拷贝和浅拷贝  

3.2.1 浅拷贝

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

       可以使用深拷贝解决浅拷贝问题，即：每一个对象都有一份独立的资源，不要和其他对象共享。 

3.2.2 深拷贝

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

3.3 模拟 string 类

3.3.1 传统版写法

class String
{
public:String(const char* str = ""){// 构造String类对象时，如果传递nullptr指针，可以认为程序非if (nullptr == str){assert(false);return;}_str = new char[strlen(str) + 1];strcpy(_str, str);}String(const String& s): _str(new char[strlen(s._str) + 1]){strcpy(_str, s._str);}String& operator=(const String& s){if (this != &s){char* pStr = new char[strlen(s._str) + 1];strcpy(pStr, s._str);delete[] _str;_str = pStr;}return *this;}~String(){if (_str){delete[] _str;_str = nullptr;}}private:char* _str;
};

3.3.2 现代版写法

class String
{
public:String(const char* str = ""){if (nullptr == str){assert(false);return;}_str = new char[strlen(str) + 1];strcpy(_str, str);}String(const String& s): _str(nullptr){String strTmp(s._str);swap(_str, strTmp._str);}String& operator=(String s){swap(_str, s._str);return *this;}~String(){if (_str){delete[] _str;_str = nullptr;}}
private:char* _str;
};

3.4 写时拷贝

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

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

STL的string类怎么了

面试中string的一种正确写法