【C++】String -- 详解（上）https://developer.aliyun.com/article/1514654?spm=a2c6h.13148508.setting.31.4b904f0ejdbHoA
⚪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 字段保存字符串长度，占用4个字节， 一个 size_t 字段保存从堆上开辟空间总的容量，占用4个字节 。
最后，还有一个指针做一些其他事情，占用4个字节 。
故总共占 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类的模拟实现
模拟实现 string 类，最主要是实现 string 类的构造、拷贝构造、赋值运算符重载以及析构函数。
1、浅拷贝
浅拷贝 ：也称位拷贝，编译器只是将 对象中的数据 按字节序拷贝过来。 如果对象中管理资源，最后就会导致多个对象共享同一份资源，当一个对象销毁时就会将该资源释放掉，而此时另一些对象不知道该资源已经被释放，以为 还有效，所以当继续对资源进项操作时，就会发生发生了访问违规。
// 为了和标准库区分，此处使用String class String { public: // 构造函数 String(const char* pStr = "") { // 构造String类对象时，如果传递nullptr指针，可以认为程序非法 if (nullptr == pStr) { assert(false); return; } _pStr = new char[strlen(pStr) + 1]; strcpy(_pStr, pStr); } // 析构函数 ~String() { if (_pStr) { delete[] _pStr; _pStr = nullptr; } } private: char* _str; }; void test() { string s1("hello"); // 用一个常量字符串去构造string类对象s1 string s2(s1); // s2调用编译器默认生成的拷贝构造函数 }
说明：上述 String 类没有显式定义其拷贝构造函数与赋值运算符重载，此时编译器会合成默认的，当用 s1 构造 s2 时，编译器会调用默认的拷贝构造。最终导致的问题是，s1、s2 共用同一块内存空间，在释放时同一块空间被释放多次而引起程序崩溃，这种拷贝方式，称为浅拷贝。
这里必须是深拷贝，编译器默认生成的拷贝构造函数是浅拷贝，会导致两个 string 对象中的字符指针 _str 指向的是同一个字符数组。（因为浅拷贝只拷贝了 _str 数组指针的 4 个字节的内容）。
所以在上述类中必须要显式定义拷贝构造函数，否则编译器默认生成的拷贝构造函数无法正常完成拷贝。
那么我们可以 采用深拷贝解决浅拷贝问题 ，即：每个对象都有一份独立的资源，不要和其他对象共享。
浅拷贝引发的问题：
- 同一块空间会被析构多次。
- 一个对象修改会影响另外一个对象。
2、深拷贝
如果一个类中涉及到资源的管理，其拷贝构造函数、赋值运算符重载以及析构函数必须要显式给出。一般情况都是按照深拷贝方式提供。
深拷贝：给每个对象独立分配资源，保证多个对象之间不会因为共享资源问题而造成多次释放资源，导致程序崩溃。
（1）传统版写法的 String 类（拷贝构造&赋值运算符重载）
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]; // 重新开辟一块和s一样大小的空间 delete[] _str; // 释放自己的空间 _str = pStr; strcpy(pStr, s._str); // 把s的数据拷贝过来 } return *this; } ~String() { if (_str) { delete[] _str; _str = nullptr; } } private: char* _str; };
如果 new 开辟空间失败了怎么办？
所以我们先开辟空间，如果开辟空间没有失败，再去释放自己的空间。
（2）现代版写法的String类（拷贝构造&赋值运算符重载）
传统写法和现代写法的区别：
- 传统写法：想要做深拷贝，都是自己去做，自己去开辟空间，自己去拷贝想要的内容。
- 现代写法：想要做深拷贝，不是自己去做，而是去构造一个的新的临时对象，临时对象中的内容就是自己想要的内容，然后将临时对象与当前对象的成员变量分别进行交换，这样当前的对象就拿到了自己想要的内容，当函数调用结束后，临时对象出了作用域就会被自动析构。
拷贝构造函数的深拷贝（现代写法）：
赋值运算符重载函数的深拷贝（现代写法）：
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); // 拿s的内容，调用构造函数构造临时对象strTmp swap(_str, strTmp._str); // 将临时对象strTmp和当前对象的成员变量_str进行交换 } // 写法一(更好) String& operator=(String s) //传值 { // 传参时，调用拷贝构造函数，拷贝构造了一个string类对象s // 将拷贝构造出来的string类对象s和当前对象的成员变量_str进行交换 swap(_str, s._str); return *this; // 返回当前对象 } // 写法二 //String& operator=(const String& s) // 传引用 //{ // if(this != &s) // 防止自己给自己赋值 // { // String strTmp(s); // 拿s的内容，调用构造函数构造临时对象strTmp // swap(_str, strTmp._str); // 将临时对象strTmp 和当前对象的成员变量_str进行交换 // } // return *this; //} ~String() { if (_str) { delete[] _str; _str = nullptr; } } private: char* _str; };
赋值运算符重载函数的深拷贝中的方法二的缺点：需要进行额外的判断和创建临时对象，增加了代码的复杂度和开销。
（3）string 类的结构
string 是对字符串进行管理的类。实际上就是一个管理字符数组的顺序表。
#include <iostream> #include <cstring> #include <cassert> using namespace std; namespace xyl { class string { public: // 迭代器 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; } // 返回指向最后一个字符下一个字符的迭代器 // 默认成员函数： string(const char* str = ""); // 默认构造函数 void swap(string& s); // 交换两个对象的内容 string(const string& s); // 拷贝构造函数(深拷贝) string& operator=(string s); // 赋值运算符重载(深拷贝) ~string(); // 析构函数 // 访问元素([]运算符重载) char& operator[](size_t pos); // 可读可写 const char& operator[](size_t pos) const; // 只读不能写 // 容量操作： size_t size() const { return _size; } // 获取字符串有效元素个数 size_t capacity() const { return _capacity; } // 获取字符串容量(有效字符的最大容量) void clear() { _str[0] = '\0'; _size = 0; } // 清空有效字符 void reserve(size_t n); // 更改容量(capacity)的大小 void resize(size_t n, char ch = '\0'); // 调整字符串有效字符的长度 // 修改操作： string& insert(size_t pos, const char ch); // 在pos位置插入一个字符 string& insert(size_t pos, const char* str); // 在pos位置插入一个字符串 void push_back(const char ch); // 尾插一个字符 void append(const char* str); // 在当前字符串末尾追加一个字符串 string& operator+=(const char ch); // 当前字符串末尾追加一个字符 string& operator+=(const char* str); // 当前字符串末尾追加一个字符串 string& operator+=(const string& s); // 当前字符串末尾追加一个字符/字符串 string& erase(size_t pos = 0, size_t len = npos); // 删除从pos位置开始的len个字符 // String operations size_t find(char ch, size_t pos = 0) const; // 从pos位置开始查找字符，若找到，则返回该字符的下标，若没找到，则返回npos size_t find(const char* str, size_t pos = 0) const; // 从pos位置开始查找子串，若找到，则返回该子串首字符的下标，若没找到，则返回npos char* c_str() const { return _str; } // 返回指向 C 格式字符串的数组的指针 private: char* _str; // 指向字符数组 size_t _size; // 有效字符数 size_t _capacity; // 有效字符容量，不包含最后作标识的'\0' static const size_t npos; }; const size_t string::npos = -1; };
（4）写时拷贝
写时拷贝 就是一种拖延症，是在浅拷贝的基础之上增加了引用计数的方式来实现的。
引用计数：用来记录资源使用者的个数。在构造时，将资源的计数给成 1，每增加一个对象使用该资源，就给计数增加 1，当某个对象被销毁时，先给该计数减 1，然后再检查是否需要释放资源，如果计数为 1，说明该对象时资源的最后一个使用者，将该资源释放；否则就不能释放，因为还有其他对象在使用该资源。
（5）string类的模拟实现
#pragma once #include <iostream> #include <assert.h> using namespace std; namespace xyl { class string { public: typedef char* iterator; public: // 默认构造函数 string(const char* str = "") // 空串并不是什么都没有，第一个字符为'\0' :_size(strlen(str)) ,_capacity(_size) { _str = new char[_capacity + 1]; // +1是确保有足够的空间存储字符串,因为还需要额外的一个字节来存储'\0' strcpy(_str, str); // 拷贝数据 } // 拷贝构造函数（深拷贝） // s2(s1) string(const string& s) :_str(nullptr) // 当前对象是一个正在构造的对象，成员变量还未初始化，是一个随机值，所以先置空 ,_size(0) ,_capacity(0) { string tmp(s._str); // 拿s的内容，调用构造函数构造临时对象tmp this->swap(tmp); // 将临时对象tmp和当前对象的成员变量分别进行交换 } // 赋值运算符重载（深拷贝） // s1 = s2 string& operator=(string s) { this->swap(s); // 将拷贝构造的对象s和当前对象的成员变量分别进行交换 return *this; // 返回当前对象 } // 析构函数 ~string() { delete[] _str; _str = nullptr; } // iterator iterator begin() { return _str; } iterator end() { return _str + _size; } // modify // 在pos位置上插入字符c，并返回该字符的位置 // 在pos位置插入一个字符 string& insert(size_t pos, const char ch) { assert(pos >= 0 && pos <= _size); if (_size == _capacity) // 先检查是否需要扩容 { // 防止是空串""，容量为0，扩容失败 size_t newcapacity = _capacity == 0 ? 4 : 2 * _capacity; reserve(newcapacity); } // 挪动字符 for (size_t i = _size + 1; i > pos; i--) // 注意 { _str[i] = _str[i - 1]; } _str[pos] = ch; // 插入字符 _size++; // 有效字符个数+1 return *this; } // 在pos位置插入一个字符串 string& insert(size_t pos, const char* str) { assert(pos >= 0 && pos <= _size); size_t len = strlen(str); if (_size + len >= _capacity) // 先检查是否需要扩容 { reserve(_size + len); } // 挪动字符 for (size_t i = _size + len; i >= pos + len; i--) { _str[i] = _str[i - len]; } // 插入字符 for (size_t i = 0; i < len; i++) { _str[pos++] = str[i]; } _size += len; // 更新有效字符个数 return *this; } void push_back(char c) { / *if (_size >= _capacity) // 先检查是否需要扩容 { // 防止是空串""，容量为0，扩容失败 size_t newcapacity = _capacity == 0 ? 4 : 2 * _capacity; reserve(newcapacity); // 扩2倍容 } _str[_size] = c; // 尾插字符 _size++; // 有效字符个数+1 _str[_size] = '\0'; // 补上字符串结束标志'\0' */ insert(_size, ch); } string& erase(size_t pos = 0, size_t len = npos) { assert(pos >= 0 && pos < _size); // 1. 从pos位置开始，后面的字符删除完，这是一个O(1)的操作 if (len == npos || pos + len >= _size) { _str[pos] = '\0'; _size = pos; } // 2. 从pos位置开始，后面的字符删除一部分，这是一个O(n)的操作 else { strcpy(_str + pos, _str + pos + len); _size -= len; } return *this; } string& operator+=(const char c) { push_back(c); return *this; } string& operator+=(const char* str) { append(str); return *this; } string& operator+=(const string& s) { append(s._str); return *this; } void append(const char* str) { /* size_t len = strlen(str); if (_size + len > _capacity) // 先检查是否需要扩容 { reserve(_size + len); // 扩容 } strcpy(_str + _size, str); // 尾插字符串(strcpy会拷贝'\0'，并在该点停止) _size += len; // 有效字符个数+len */ insert(_size, str); } void clear() { _size = 0; _str[_size] = '\0'; } // s1.swap(s2); void swap(string& s) { // 函数名冲突，指定去调用全局域里面的::swap ::swap(_str, s._str); ::swap(_size, s._size); ::swap(_capacity, s._capacity); } // capacity size_t size()const { return _size; } size_t capacity()const { return _capacity; } bool empty()const { return 0 == _size; } // 调整字符串有效字符的长度 void resize(size_t n, char ch = '\0') { // 要调整的有效字符的长度小于原有_size大小 if (n < _size) { _size = n; // 更新有效字符个数 _str[_size] = '\0'; // 补上字符串结束标志'\0' } // 要调整的有效字符的长度大于原有_size大小 else if (n > _size) { // 要调整的有效字符的长度大于原有_capacity大小，先进行增容 if (n > _capacity) reserve(n); // 多出的位置用字符ch(缺省值'\0')进行填充 for (size_t i = _size; i < n; i++) { _str[i] = ch; } _size = n; // 更新有效字符个数 _str[_size] = '\0'; // 补上字符串结束标志'\0' } } // 更改容量（capacity）的大小 void reserve(size_t n) { if (n > _capacity) // 如果新容量大于旧容量，则开辟空间 { // 开辟新空间 char* tmp = new char[n + 1]; strcpy(tmp, _str); // 旧空间数据拷贝到新空间 // 释放旧空间，使用新空间 delete[] _str; _str = tmp; // 指向新空间 _capacity = n; // 更新容量 } } // access char& operator[](size_t index) // 用于访问字符串中指定位置的字符 { assert(index < _size); return _str[index]; } // 普通版本和const版本 char& operator[](size_t pos) // 可读可写 { assert(pos < _size); return _str[pos]; // *(_str + pos) } const char& operator[](size_t pos) const // 只读不能写 { assert(pos < _size); return _str[pos]; // *(_str + pos) } // 比较两个对象的大小（按字符ascii码比较） // s1 > s2 bool operator>(const string& s1, const string& s2) { // 指针 i 和 j 分别指向两个字符串的第一个字符 size_t i = 0, j = 0; for (; i < s1.size() && j < s2.size(); i++, j++) // 同时遍历两个字符串 { if (s1[i] != s2[j]) return s1[i] > s2[j]; } if (i == s1.size() && j == s2.size()) return false; // 同时被遍历完，说明 s1 = s2 else if (i == s1.size()) return false; // s1先被遍历完，说明 s1 < s2 else if (j == s2.size()) return true; // s2先被遍历完，说明 s1 > s2 } // s1 == s2 bool operator==(const string& s1, const string& s2) { // 指针 i 和 j 分别指向两个字符串的第一个字符 size_t i = 0, j = 0; for (; i < s1.size() && j < s2.size(); i++, j++) // 同时遍历两个字符串 { if (s1[i] != s2[j]) return false; } if (i == s1.size() && j == s2.size()) return true; // 同时被遍历完，说明 s1 = s2 else return false; // 有一个字符串没被遍历完 } // 下面的关系运算符重载，全都可以复用上面的代码 // s1 != s2 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; } // s1 < s2 bool operator<(const string& s1, const string& s2) { return !(s1 >= s2); } // s1 <= s2 bool operator<=(const string& s1, const string& s2) { return !(s1 > s2); } // 返回c在string中第一次出现的位置 size_t find(char c, size_t pos = 0) const { assert(pos >= 0 && pos < _size); for (size_t i = pos; i < _size; i++) { if (_str[i] == c) return i; } return npos; } // 返回子串s在string中第一次出现的位置 size_t find(const char* s, size_t pos = 0) const { assert(pos >= 0 && pos < _size); // 在原串中去匹配子串s // 匹配成功，返回子串s首字符的地址 // 匹配失败，返回空指针 const char* p = strstr(_str + pos, s); if (p) return p - _str; // 通过子串s首字符的地址，计算出首字符的下标 else return npos; } private: friend ostream& operator<<(ostream& _cout, const xyl::string& s); friend istream& operator>>(istream& _cin, xyl::string& s); private: char* _str; size_t _capacity; size_t _size; }; ostream& operator<<(ostream& _cout, const xyl::string& s) { // 不能使用cout, 因为string的字符串内部可能会包含\0 // 直接cout时, 是将_str当成char*打印的，遇到内部的\0时后序内容就不打印了 //cout << s._str; for (size_t i = 0; i < s.size(); ++i) { _cout << s[i]; } return _cout; } istream& operator>>(istream& _cin, string& s) { // 一个一个字符输入 // 遇到空格或者换行符终止输入 char c; _cin >> c; // 从流中获取一个字符 while (c != ' ' && c != '\n') { s += c; // 把提取的字符追加到sting类对象s中去 _cin >> c; // 继续从流中获取下一个字符 } return _cin; } } int main() { xyl::string s1("hello"); s1.push_back(' '); s1.push_back('w'); s1.push_back('o'); s1.push_back('r'); s1 += 'l'; s1 += 'd'; cout << s1 << endl; //hello world cout << s1.size() << endl; //11 cout << s1.capacity() << endl; //20 // 利用迭代器打印string中的元素 xyl::string::iterator it = s1.begin(); while (it != s1.end()) { cout << *it; ++it; } cout << endl; // 这里可以看到一个类只要支持的基本的iterator，就支持范围for for (auto ch : s1) { cout << ch; } cout << endl; return 0; }
