《回溯 C++98：string 核心机制拆解 —— 从拷贝策略到高效 swap》
🔥草莓熊Lotso：个人主页
❄️个人专栏：《C++知识分享》《Linux 入门到实践：零基础也能懂》
✨生活是默默的坚持，毅力是永久的享受。
🎬博主简介：
目录
前言：
一. 字符串的拷贝机制：从浅拷贝到写时拷贝
1.1 浅拷贝：隐藏的 “双重释放” 陷阱
1.2 深拷贝：独立内存的安全保障
1.2.1 传统版写法的string类
1.2.2 现代版写法的string类
1.3 写时拷贝（了解就可以）：读写分离的优化策略
二、C++98/03 中的三种 swap 实现
2.1 成员函数 swap：O (1) 级别的高效交换
2.2 全局 swap（默认实现）：低效的拷贝交换
2.3 全局 swap（优化版本）：复用成员 swap 的高效实现
三、总结：拷贝与交换的设计巧思
结尾：
前言：
在 C++11 引入移动语义之前，std::string 的实现依赖于深拷贝、写时拷贝（Copy-On-Write）等经典内存管理策略，而swap 操作则是提升性能的关键优化点。本文聚焦 C++11 之前string的三大swap实现与拷贝机制，带你理解早期字符串类设计的核心智慧。
一. 字符串的拷贝机制：从浅拷贝到写时拷贝
字符串的拷贝是内存管理的核心场景，错误的拷贝实现会导致内存泄漏或程序崩溃，而优化的拷贝策略则能显著提升性能。
1.1 浅拷贝：隐藏的 “双重释放” 陷阱
浅拷贝是最直观但危险的拷贝方式，其本质是仅复制指针地址而非实际数据，导致多个对象共享同一块内存。
问题展现：
namespace Lotso
{class string {private:char* _str;size_t _size;public:// 构造函数：分配内存并初始化string(const char* str = "") : _size(strlen(str)) {_str = new char[_size + 1];strcpy(_str, str);}// 未实现深拷贝，使用编译器默认的浅拷贝~string() { delete[] _str; } // 析构时释放内存};// 崩溃int main() {string s1("hello");string s2 = s1; // 浅拷贝：s1._str 与 s2._str 指向同一块内存return 0;// 析构时：s2 先释放内存，s1 再释放已被释放的内存→两个释放同一块内存程序崩溃}
};
问题根源：就像一个家庭中有两个孩子，但父母只买了一份玩具，两个孩子愿意一块玩，则万事大吉，万一不想分享就你争我夺，玩具损坏。
1.2 深拷贝：独立内存的安全保障
深拷贝通过为每个对象分配独立内存并复制数据，彻底避免资源共享，是最安全的拷贝方式。
1.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];strcpy(pStr, s._str);delete[] _str;_str = pStr;}return *this;}~String(){if (_str){delete[] _str;_str = nullptr;}}
private:char* _str;
};优势：每个对象拥有独立内存，析构时不会冲突；
缺点：每次拷贝都需分配内存和复制数据，效率较低（O (n) 时间复杂度）
1.2.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);swap(_str, strTmp._str);}// 对比下和上面的赋值那个实现比较好？String& operator=(String s){swap(_str, s._str);return *this;}/*String& operator=(const String& s){if(this != &s){String strTmp(s);swap(_str, strTmp._str);}return *this;}*/~String(){if (_str){delete[] _str;_str = nullptr;}}
private:char* _str;
};核心逻辑：借助临时对象的深拷贝，通过swap将临时对象的资源 “转移” 到当前对象，临时对象析构时会自动释放原对象的旧内存，既避免数据丢失，又简化代码。
1.3 写时拷贝（了解就可以）：读写分离的优化策略
- 写时拷贝就是一种拖延症，是在浅拷贝的基础之上增加了引用计数的方式来实现的。
- 引用计数：用来记录资源使用者的个数。在构造时，将资源的计数给成1，每增加一个对象使用该资源，就给计数增加1，当某个对象被销毁时，先给该计数减1，然后再检查是否需要释放资源，如果计数为1，说明该对象时资源的最后一个使用者，将该资源释放；否则就不能释放，因为还有其他对象在使用该资源。
- 推荐两篇大佬的文章：
C++ STL string的Copy-On-Write技术 | 酷 壳 - CoolShell
https://coolshell.cn/articles/1443.html
- 扩展阅读：
C++面试中string类的一种正确写法 | 酷 壳 - CoolShell
STL 的string类怎么啦？_string拥有庞大字符串 c++-CSDN博客
二、C++98/03 中的三种 swap 实现
- swap用于交换两个字符串的内容，不同实现的效率差异显著，核心是 “是否避免数据拷贝”。
2.1 成员函数 swap：O (1) 级别的高效交换
string类的成员swap直接交换底层资源（指针、大小、引用计数等），不涉及数据拷贝，是效率最高的实现。
代码实现：
class String {
public:void swap(String& s) {// 交换核心成员，无数据拷贝std::swap(_str, s._str);std::swap(_size, s._size);std::swap(_capacity, s._capacity);}
private:char* _str;size_t _size;size_t _capacity;
};优势：
- 效率极致：无论字符串长度如何，均为 O (1) 时间复杂度；
- 无内存风险：交换后资源所有权转移，析构时各自释放原有资源。
2.2 全局 swap（默认实现）：低效的拷贝交换
C++ 标准库提供的全局std::swap模板，默认逻辑是 “拷贝 - 覆盖 - 析构”，对字符串而言效率极低。
代码实现：
template <class T>
void swap(T& a, T& b)
{T c(a);// 深拷贝 a 到临时对象（O(n)a = b; //深拷贝 b 到 a（O(n)）b = c;// 深拷贝临时对象到 b（O(n)）
}问题：对长字符串而言，三次深拷贝会导致 O (n) 时间复杂度，性能极差。
2.3 全局 swap（优化版本）：复用成员 swap 的高效实现
为解决默认swap的低效问题，标准库会为std::string提供模板特化，直接调用成员swap，将效率提升至 O (1)。
代码实现：
inline void swap(string& a, string& b)
{//还是调的库里的a.swap(b);
}优势：兼顾通用性与效率，在模板函数（如排序算法）中使用试探大std::swap时，仍能享受高效交换。
三、总结：拷贝与交换的设计巧思
在 C++11 之前，string的设计围绕 “内存效率” 与 “安全性” 展开：
拷贝机制的选择：
- 深拷贝：安全但低效，适合写操作频繁的场景；
- 写时拷贝：读多写少场景下的优化，但存在线程安全与迭代器失效问题，现代编译器已逐渐弃用。
swap 实现的最优实践：
- 优先使用成员swap：直接交换资源，效率最高；
- 全局swap优化：标准库已帮我们优化，无需手动实现，但需知道其底层依赖成员swap的本质。
结尾：
往期回顾：
《告别 “会用不会讲”：C++ string 底层原理拆解 + 手撕实现，面试 / 开发都适用》
结语：回溯 C++98/03 string 的拷贝与 swap 机制，既是理解早期内存管理智慧的钥匙，也为掌握现代 C++ 容器设计打下根基。
✨把这些内容吃透超牛的！放松下吧✨
ʕ˘ᴥ˘ʔ
づきらど
