一、为什么学习string类？

• C语言中，字符串是以’\0’结尾的一些字符的集合，为了操作方便，C标准库中提供了一些str系列的库函数，但是这些库函数与字符串是分离开的，不太符合OOP的思想，而且底层空间需要用户自己管理，稍不留神可能还会越界访问。
• 在OJ中，有关字符串的题目基本以string类的形式出现，而且在常规工作中，为了简单、方便、快捷，基本都使用string类，很少有人去使用C库中的字符串操作函数。

二、标准库中的string类

  1. 定义

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. 不能操作多字节或者变长字符的序列。

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

  2. 常用接口说明

     2.1 构造

// 1.测试string构造相关的接口
void text_string1()
{//常用string s1; //构造空string类对象string s2("Hello World!"); //用c字符串构造string s3(s2); //拷贝构造//不常用 了解即可string s4(s2, 2, 5); //从s2 下标2的位置开始，选择其及往后5个位置 拷贝构造s4string s5(s2, 2); //同上，第三个参数使用缺省值npos（结合相关文档），从下标2位置开始，有多少拷贝多少string s6(s2, 2, 30); //同上，第三个参数传参值大于 指定对象总长度时，也是有多少拷贝多少string s7("Hello World!", 5); //给定c字符串，从头顺序拷贝 指定个数的字符string s8(10, 'x'); //用指定个数 的指定字符 填充构造cout << s1 << endl;cout << s2 << endl;cout << s3 << endl;cout << s4 << endl;cout << s5 << endl;cout << s6 << endl;cout << s7 << endl;cout << s8 << endl;
}

     2.2 容量操作

注意：

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在改变元素个数时，如果是将元素个数增多，可能会改变底层容量的大小，如果是将元素个数减少，底层空间总大小不变。

// 2.测试string容量相关的接口  size/clear/resize
void text_string2()
{//1. 注意：string类对象支持直接用cin和cout进行输入和输出cout << "下方为1：" << endl;string s("hello, bit!!!");cout << s.size() << endl;cout << s.length() << endl;cout << s.capacity() << endl;cout << s << endl;cout << endl;//2. 将s中的字符串清空，注意清空时只是将size清零，不改变底层空间的大小cout << "下方为2：" << endl;s.clear();cout << s.size() << endl;cout << s.capacity() << endl;cout << endl;//3. 将s中有效字符个数增加到10个，多出位置用'a'进行填充// “aaaaaaaaaa”cout << "下方为3：" << endl;s.resize(10, 'a');cout << s.size() << endl;cout << s.capacity() << endl;cout << s << endl;cout << endl;//4. 将s中有效字符个数增加到15个，多出位置用缺省值'\0'进行填充// "aaaaaaaaaa\0\0\0\0\0"cout << "下方为4：" << endl;s.resize(15);cout << s.size() << endl;cout << s.capacity() << endl;cout << s << endl;cout << endl;//5. 将s中有效字符个数缩小到5个 -> 删除cout << "下方为5：" << endl;s.resize(5);cout << s.size() << endl;cout << s.capacity() << endl;cout << s << endl;cout << endl;//6. 测试reserve是否会改变string中有效元素个数 -> 不会,单纯扩容cout << "下方为6：" << endl;s.reserve(100);cout << s.size() << endl;cout << s.capacity() << endl;cout << endl;//7. 测试reserve参数小于string的底层空间大小时，是否会将空间缩小 -> 不会，无变化cout << "下方为7：" << endl;s.reserve(50);cout << s.size() << endl;cout << s.capacity() << endl;cout << endl;
}// 利用reserve提高插入数据的效率，避免增容带来的开销
//====================================================================================
void text_PushBack() //多次扩容，开销大
{string s;size_t cap = s.capacity();cout << "无reserve的扩容情况:\n";for (int i = 0; i < 100; ++i){s.push_back('c');if (cap != s.capacity()){cap = s.capacity();cout << "capacity changed: " << cap << endl;}}
}void text_PushBackReserve() //减少扩容次数，节省开销
{string s;s.reserve(100);size_t cap = s.capacity();cout << "有reserve的扩容情况:\n";for (int i = 0; i < 100; ++i){s.push_back('c');if (cap != s.capacity()){cap = s.capacity();cout << "capacity changed: " << cap << '\n';}}
}

     2.3 访问及遍历操作

// string的访问  s[]
void text_string3()
{string s1("hello Bit");const string s2("Hello Bit");cout << s1 << " " << s2 << endl;cout << s1[0] << " " << s2[0] << endl;s1[0] = 'H';cout << s1 << endl;// s2[0] = 'h';   代码编译失败，因为const类型对象不能修改
}//string的遍历 -> begin()+end()   for+[]  范围for
// 注意：string遍历时使用最多的还是for+下标 或者 范围for(C++11后才支持)
void text_string4()
{string s("hello Bit");// 3种遍历方式：// 需要注意的以下三种方式除了遍历string对象，还可以遍历是修改string中的字符，// 另外以下三种方式对于string而言，第一种使用最多// 1. for+operator[]for (size_t i = 0; i < s.size(); ++i)cout << s[i] << " ";//cout << s1.operator[](i) << endl;cout << endl;// 2.迭代器string::iterator it = s.begin();while (it != s.end()){cout << *it << " ";++it;}cout << endl;// string::reverse_iterator rit = s.rbegin();// C++11之后，直接使用auto定义迭代器，让编译器推到迭代器的类型auto rit = s.rbegin();while (rit != s.rend()){cout << *rit << " ";++rit;}cout << endl;// 3.范围forfor (auto ch : s)cout << ch << endl;
}

     2.4 修改操作

注意：

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

// 测试string：
// 1. 插入(拼接)方式：push_back  append  operator+= 
// 2. 正向和反向查找：find() + rfind()
// 3. 截取子串：substr()
// 4. 删除：erase
void text_string5()
{//1. 插入与追加cout << "下方为1：" << endl;string str;str.push_back(' ');   // 在str后插入空格str.append("hello");  // 在str后追加一个字符"hello"str += 'b';           // 在str后追加一个字符'b'   str += "it";          // 在str后追加一个字符串"it"cout << str << endl;cout << str.c_str() << endl;   // 以C语言的方式打印字符串cout << endl;//2. 获取file的后缀cout << "下方为2：" << endl;string file("string.cpp");size_t pos = file.rfind('.');	// pos缺省值为npos，是string里面的一个静态成员变量// static const size_t npos = -1; 由于为无符号数，实际为整形最大值，// 效果为从字符串最末尾开始往前找string suffix(file.substr(pos, file.size() - pos));cout << suffix << endl;cout << endl;//3. 取出url中的域名cout << "下方为3：" << endl;string url("http://www.cplusplus.com/reference/string/string/find/");cout << url << endl;size_t start = url.find(':'); //pos缺省值为0，从字符串第一个字符位置开始往后找if (start == string::npos) //find/rfind 未找到指定字符时 返回npos{cout << "invalid url" << endl;return;}start += 3;size_t finish = url.find('/', start);string address = url.substr(start, finish - start);cout << address << endl;cout << endl;//4. 删除url的协议前缀cout << "下方为4：" << endl;pos = url.find("://");url.erase(0, pos + 3); //删除cout << url << endl;cout << endl;
}

     2.5 非成员函数

上面的几个接口大家了解一下，下面的OJ题目中会有一些体现他们的使用。string类中还有一些其他的操作，这里不一一列举，大家在需要用到时不明白了查文档即可。

三、OJ练习自测

  1. 仅仅反转字母

class Solution {
public:bool isLetter(char ch){if(ch >='a' && ch <= 'z')return true;if(ch >= 'A' && ch <= 'Z')return true;return false;}string reverseOnlyLetters(string s) {if(s.empty())return s;size_t begin = 0;size_t end = s.size()-1;while(begin < end){while(begin < end && !isLetter(s[begin]))++begin;while(begin < end && !isLetter(s[end]))--end;swap(s[begin],s[end]);++begin;--end;}return s;}
};

  2. 找字符串中第一个只出现的字符

class Solution {
public:int firstUniqChar(string s) {int count[128] = {0};for(int i = 0;i<s.size();i++){count[s[i]]++; //s[i]会转换为ascll码值，具有唯一标识数// i标识的是字符串的下标}for(int i = 0;i<s.size();i++){if(count[s[i]] == 1)return i;}return -1;}
};

  3. 字符串最后一个单词长度

#include <iostream>
#include <string>
using namespace std;int main() {string s;while(getline(cin, s)) //多组输入，题目要求不为空串，则为空时结束{size_t pos = s.rfind(' ');cout << s.size()-pos-1 << endl;}return 0;
}

  4. 验证回文串

class Solution {
public:bool IsLetterOrNumber(char ch){if(ch>='A' && ch <='Z'|| ch>='a' && ch<='z'|| ch>='0' && ch<='9')return true;return false;}bool isPalindrome(string s) {for(auto& ch : s){//将大写字符转为小写if(ch>='A' && ch<='Z')ch += 32;}//验证是否回文int begin = 0;int end = s.size()-1; //不能用size_t,串有可能为空，则为负数while(begin < end){while(begin < end && !IsLetterOrNumber(s[begin]))++begin;while(begin < end && !IsLetterOrNumber(s[end]))--end;if(s[begin] != s[end])return false;++begin;--end;}return true;}
};

  5. 字符串相加

class Solution {
public:string addStrings(string num1, string num2) {string tmp;int cur1 = num1.size() - 1;int cur2 = num2.size() - 1;int next = 0;while (cur1 >= 0 || cur2 >= 0){int x1 = cur1 >= 0 ? num1[cur1--]-'0' : 0;int x2 = cur2 >= 0 ? num2[cur2--]-'0' : 0;int sum = x1 + x2 + next;next = sum/10; //处理进位sum = sum % 10;//tmp.insert(0,1, sum + '0'); 头插时间复杂度为 N^2，则可先尾插再逆置tmp += (sum+'0'); }if(next == 1) //最后一位为进位，要格外判断加上进位1tmp += '1';reverse(tmp.begin(), tmp.end());return tmp;}
};

四、string类的模拟实现

  0. 整体框架

//模拟实现string类
namespace Mystr //用命名空间封装，以免和std中的string冲突，调用方式如主函数
{class string{public:string(const char* str = "");string(const string& s);~string();string& operator=(string& s);const char* c_str() const;//...各类函数接口private:char* _str;size_t _size;size_t _capacity;const static size_t npos;//const static size_t npos = -1; √ 只有整型可以用缺省值//const static double npos = -1.0; ×};
}int main()
{Mystr::string s1 = "abc"; //调用指定命名空间域的模拟string类s1.push_back('a');//...return 0;
}

  1. 构造 / 析构 / 拷贝 / 赋值

namespace bit
{const size_t string::npos = -1;//1.0 构造（带参）/* V1版本 三个strlen效率低string::string(const char* str):_str(new char[strlen(str) + 1]),_size(strlen(str)),_capacity(strlen(str)){strcpy(_str, str);}*//* V2版本 忘记初始化列表初始化顺序=成员变量的声明顺序 string::string(const char* str):_size(strlen(str)), _str(new char[_size + 1]), _capacity(_size){strcpy(_str, str);}*//* V3最终版 初始化列表与函数体内赋值 相结合 */string::string(const char* str):_size(strlen(str)){_str = (new char[_size + 1]);_capacity = _size;strcpy(_str, str);}//1.1 构造（无参）/* V1版本 不开空间× string::string(){_str = nullptr;_size = _capacity = 0;}*//*V2版本 无参和带参分开写string::string(){_str = new char[1]{ '\0' };_size = _capacity = 0;}*//*V3版本 和构造带参V3版本一样，将全缺省和无参合二为一，声明处给缺省值即可*///1.2 拷贝构造（深拷贝，需要手动控制 开新空间）string::string(const string& s){_str = new char[s._capacity];strcpy(_str, s._str);_size = s._size;_capacity = s._capacity;}//1.3 赋值运算符重载string& string::operator=(string& s){if (this != &s)//判断是否为自己给自己赋值{char* tmp = new char[s._capacity + 1];strcpy(tmp, s._str);delete[] _str;_str = tmp;_size = s._size;_capacity = s._capacity;}return *this;}//1.4 析构string::~string(){delete[] _str;_str = nullptr;_size = _capacity = 0;}
}

• 注释补充：

本文采用声明和定义分离的方式模拟string，注意事项如下（不分离的不用看）：
 ① 声明和定义都用命名空间域包起来防止冲突，链接时会自动合并（同名namespace）
 ② 定义时要指定类域，否则会报错（函数名前加string::）

     1.0 构造

思路：
 ① 开空间并赋值
 ② 更新_size，_capacity

问题（V1，V2版本）：

1. 多次使用strlen计算字符串长度，效率低
2. 如果想复用已经初始化好的，需要保证声明顺序，容易出错不建议这种做法
   （初始化列表初始化顺序 = 成员变量的声明顺序）

     1.1 构造（无参）

1. 是否要开空间？ --> 必须开
    流输出 cout 打印 const char* 指针类型，不会像其他指针一样 打印指针本身的值，而是去打印指针指向的内容（字符串），即默认发生解引用，会去找到‘/0’才停止。
    而此时未开辟空间，为空指针，对空指针解引用会出错
2. 可使用缺省参数将 全缺省和无参 合二为一
   ① 声明和定义分离：
    声明处写为 string(const char* str = ""); 定义处不变
   ② 不分离：
     定义处写

     1.3 赋值运算符重载

思路：
 ① 开新空间并赋值
 ② 释放旧空间
 ③ 更新_size，_capacity
优化：
 ① 判断是否为自己给自己赋值，自赋值时可不必开新空间

  2. 增 删 查 改

namespace bit
{
//5. c_strconst char* string::c_str() const{return _str;}//6. sizesize_t string::size() const{return _size;}//7. findsize_t string::find(char ch, size_t pos){for (size_t i = pos; i < _size; i++){if (_str[i] == ch)return i;}return npos;}size_t string::find(const char* sub, size_t pos)//查找子串{char* p = strstr(_str + pos, sub); return p - _str; //指针加减运算}//8. operator[]char& string::operator[](size_t pos){assert(pos < _size);return _str[pos];}//const版本const char& string::operator[](size_t pos) const{assert(pos < _size);return _str[pos];}//9. 迭代器（用指针模拟）typedef char* iterator;typedef const char* const_iterator;string::iterator string::begin(){return _str;}string::iterator string::end(){return _str + _size;}//const版本string::const_iterator string::begin() const{return _str;}string::const_iterator string::end() const{return _str + _size;}//10. reservevoid string::reserve(size_t n){if (n > _capacity) //一般不缩容{char* tmp = new char[n + 1];//多开一个给'/0'strcpy(tmp, _str);delete[] _str;
._str = tmp;_capacity = n;}}//11. push_backvoid string::push_back(char ch){if (_size + 1 > _capacity){//赋值运算符优先级最低，先进行三目运算符判断，最后赋值size_t newcapacity = _capacity == 0 ? 4 : _capacity * 2;reserve(newcapacity);//reserve(_size + 1); //需要多少开多少，也可以如上多开空间适用于多次插入的情景}_str[_size] = ch;_str[_size + 1] = '/0';++_size;}//复用insert 版本void string::push_back(char ch){insert(_size, ch);}//12. appendvoid string::append(const char* str){size_t len = strlen(str);if (_size + len > _capacity){reserve(_size + len);}//strcat(_str, str); 效率低，要从头开始遍历找'/0'位置strcpy(_str + len, str);_size += len;}//复用insert 版本void string::append(const char* str){insert(_size, str);}//13. operator+=string& string::operator+=(char ch) //字符{push_back(ch);return *this;}string& string::operator+=(const char* str)//字符串{append(str);return *this; //要适用于连续赋值情景，返回左操作数}//14. insertvoid string::insert(size_t pos, char ch){assert(pos < _size);if (_size + 1 > _capacity){size_t newcapacity = _capacity == 0 ? 4 : _capacity * 2;reserve(newcapacity);}/* 若为头插，即pos == 0，需注意一下两种写法写法1：循环结束条件为end<0，end起始位置为size，将end位挪给end后一位注意：①将end写为int类型②强转size类型为int原因：设计上为while循环结束条件为 end < 0，即最后一次挪动为_str[1] = _str[0]，end--为-1，退出循环。但size_t为无符号整形，没有负数的概念，-1表示的是整形最大值，所以应该写为 注意①事项；且据C语言中所学，运算符两边操作数类型不同时，会发生类型提升：一般为类型小的向类型大的提升，int向size_t提升，所以用size赋值end时要写为 注意②事项//方法1 将end移向end后一位/*int end = _size; //end指向末尾位置'/0'位置，若指向有效字符的末字符位置，则会把'/0'覆盖掉，后续要手动加上while (end >= (int)pos){_str[end + 1] = _str[end];--end;}*///方法2 将end前一位移向endsize_t end = _size + 1; //end指向'/0'后一位while (end >= pos-1){_str[end] = _str[end - 1];--end;}_str[pos] = ch;++_size;}void string::insert(size_t pos, const char* str){assert(pos < _size);size_t len = strlen(str);if (_size + len > _capacity){reserve(_size + len);}//方法1 将end 移向 end+len位/*int end = _size;while (end >= (int)pos) //end > pos-1{_str[end + 1en] = _str[end];--end;}*///方法2 将end-len 移向 end位size_t end = _size + len;while (end >= pos+len) //end > pos+len-1{_str[end] = _str[end - len];--end;}//memcpy(_str + pos, str,len); 都可以strcpy(_str + pos, str);_size += len;}//15. erasevoid string::erase(size_t pos, size_t len){assert(pos < _size);// len大于后续字符个数时，有多少删多少if (len >= _size - pos){_str[pos] = '/0'; //直接置'/0'_size = pos;}else{//移动覆盖strcpy(_str + pos, _str + pos + len);_size -= len;}}
//16. substrstring string::substr(size_t pos, size_t len){// len大于后面剩余字符，有多少取多少if (len > _size - pos){string sub(_str + pos);return sub;}else{string sub;sub.reserve(len);for (size_t i = 0; i < len; i++){sub[i] = _str[pos + i];}return sub;}}
}

//迭代器测试函数
void test_string2()
{string s3("hello world");for (auto ch : s3){cout << ch << " ";}cout << endl;string::iterator it3 = s3.begin();while (it3 != s3.end()){cout << *it3 << " ";++it3;}cout << endl;
}

     2.0 迭代器

注意：
 ① 重载一般版本和const版本

     2.1 reserve

思路：
 ① 开新空间并赋值
 ② 释放旧空间
 ③ 更新_str，_capacity
注意：
 ① 一般不缩容，给定空间比现有空间小时，不变化

     2.2 push_back / append / operator+= / insert

思路：
 ① 检查容量（扩容）
 ② 插入
 ③ 更新
注意：
 ① 实现 insert 即可复用于 => push_back / append => +=
 ② 重载插入字符 和 字符串两个版本
 ③ insert 中 while循环的两种写法（‘/0’位 移向后一位，'/0’前一位移向 '/0’位）
 ④ 结束条件写法（> / >=）
  ① > x 时，=x-1时 为最后一次进入循环
  ② >= x 时，=x时 为最后一次进入循环
  ③ <= x 时，=x时 为最后一次进入循环

     2.3 erase

思路：
 分两种情况，一为有多少删多少，二为删除指定位后指定个
 1. 直接在pos位 置’/0’ 并更新_size（相当于删除后续所有字符）
 2. 将指定位后的字符 移动覆盖到 pos位后

     2.4 substr

思路：
 分两种情况，一为有多少取多少，二为取指定位后指定个 为子串
 1. 直接用pos位的 指针构造子串（字符串指针指向首字符位置，相当于传入子串的指针）
 2. 从pos位开始，依次将指定个 赋值给新串

  3. 非成员函数

namespace bit
{const size_t string::npos = -1;
//17. swap// s1.swap(s2)void string::swap(string& s){std::swap(_str, s._str);std::swap(_size, s._size);std::swap(_capacity, s._capacity);}//18. 各类运算符重载bool string::operator<(const string& s)const{return strcmp(_str, s._str) < 0;}bool string::operator==(const string& s)const{return strcmp(_str, s._str);}bool string::operator>(const string& s) const{return !(*this <= s);}bool string::operator>=(const string& s)const{return !(*this < s);}bool string::operator<=(const string& s) const{return *this < s || *this == s;}void string::clear(){_str[0] = '/0';_size = 0;}/*V1版本 istream& operator>>(istream& is, string& str){str.clear();char ch;//cin >> ch; 无法读取含空格的串ch = is.get();while (ch != ' ' && ch != '\n'){str += ch;ch = is.get();}return is;}*//*V2版本 模拟缓冲区*/istream& operator>>(istream& is, string& str){char buff[128];int i = 0;char ch = is.get();while (ch != ' ' && ch != '/n') {buff[i++] = ch;if (i == 127){buff[i] = '/0';str += buff; //数组名就是数组首元素的指针i = 0;}ch = is.get();}if (i != 0){buff[i] = '/0';str += buff;}return is;}ostream& operator<< (ostream& os, const string& str){for (size_t i = 0; i < str.size(); i++){os << str[i];}return os;}
}

     3.0 npos

注意：
 ① 为静态成员变量，类内声明 类外定义，相当于全局变量
  【若整体声明和定义分离则需要在 .h 文件中声明，.cpp 文件中定义，避免多个源文件包含.h 时发生重定义】
 ② 一般不能在声明处给缺省值（给缺省值实际是给初始化列表使用的，而静态成员变量不走初始化列表）

• 特例： const static int/size_t 类型变量 可以使用缺省值初始化

     3.1 swap

思路：
  手动交换各自的成员变量即可
问题：
  为什么std中含有 swap，string中还要再提供？又为什么提供两个？
  ① std中的 swap为模板（如上图三），代价太大（需要一次拷贝构造，两次赋值，反复开辟、释放空间）
  ② string的成员函数swap是 针对string类对象的优化写法，而非成员函数swap 是设计者怕使用者直接调用std中的模板，手动对该模板进行的实现（有现成的用现成的），其内部实际上还是调用的成员函数swap（套娃）。

string s1, s2;
s1.swap(s2); //调用成员函数 swap
swap(s1, s2); //调用非成员函数 swap（如果没有对模板中的string类型 进行实现为非成员函数，则会调用std中的模板）

     3.2 比较运算符重载

注意：
 ① 只需实现 operator<，operator== （用strcmp模拟），其余均可复用实现

     3.3 流提取（>>）

注意：
 ① cin 无法提取含空格的串，如“abc d”只能提取到 abc（因为空格和换行默认为多个值之间的分隔符），此时要使用 istream类中的函数get代替cin
 ② 流提取具有覆盖效果，此处模拟实现clear进行
优化：
 模拟缓冲区，使用buff数组避免频繁扩容（每127个字符扩一次容）
  ① 每127个字符后添加 ‘/0’（处理刚好为127倍数长度的串）
  ② 循环结束后 i ≠ 0时，添加’/0’（处理不为127倍数长度的串）

  4. 传统写法与现代写法

上文模拟实现部分就是传统写法，核心思想为自己动手做，而现代写法主要体现了复用的思想，让别人干活，交换

     4.1 拷贝构造

//现代写法 s2(s1)
string::string(const string& s)
{string tmp(s._str); //让构造干活swap(tmp); //交换成员
}

思路：

1. 复用构造，构造与s1内容一致的tmp
2. 将s2与s1 交换成员
    ① s2声明后未初始化，指向随机值，将tmp与s2交换类成员，s2得到了想要的拷贝效果
    ② 而tmp为局部变量，出作用域会调用析构函数自动销毁

     4.2 赋值运算符重载

//s1 = s3/*V1版本*/
string& string::operator=(const string& s)
{if (this != &s){//string tmp(s);string tmp(s._str);swap(tmp);}return *this;
}/*V2 版本（代码量减少，但效率不变）*/
string& string::operator=(string tmp) //调用拷贝构造tmp(s3)
{swap(tmp);return *this;
}

思路：

1. 复用构造 / 拷贝构造，构造与s3内容一致的tmp
2. 将s1与 tmp 交换成员
    ① tmp与s1交换类成员，s1得到了想要的拷贝效果
    ② 而tmp为局部变量，出作用域会调用析构函数自动销毁

五、扩展阅读

  5.1 写时拷贝

引入情景：
 深拷贝效率低，对浅拷贝进行优化处理 使之能使用

浅拷贝问题与解决：

1. 析构多次（同一块空间，不同的对象）
   => 引用计数：不为1时，计数- -
         为1时，即最后一个对象，此时才释放空间
2. 一个修改影响另一个
   => 写时拷贝：进行修改的才走深拷贝开辟空间，否则走浅拷贝共用空间（核心：不修改就赚了）

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

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

• vs下string的结构
  string总共占28个字节，内部结构稍微复杂一点，先是有一个联合体，联合体用来定义string中字符串的存储空间：
  • 当字符串长度小于16时，使用内部固定的字符数组来存放
  • 当字符串长度大于等于16时，从堆上开辟空间

union _Bxty
{ 	value_type _Buf[_BUF_SIZE];pointer _Ptr;char _Alias[_BUF_SIZE]; 
} _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类的常用接口，并对其中重点接口进行了模拟实现，以便读者了解其底层逻辑，有利于更好地使用。
尽管文章修正了多次，但由于水平有限，难免有不足甚至错误之处，敬请各位读者来评论区批评指正。