C++ string类模拟实现：深拷贝、内存管理与运算符重载实战

1. 项目概述：为什么我们要亲手“造”一个string类？

如果你正在学习C++，尤其是已经跨过了语法基础，开始接触STL（标准模板库），那么std::string绝对是你最熟悉、使用频率最高的类之一。它封装了字符数组的复杂性，让我们能像操作基本类型一样轻松处理字符串。但是，你有没有想过，这个看似简单的string类，内部到底是如何运作的？当你在代码里写下string s1 = “hello”;或者s1 = s2;时，编译器在背后为你做了哪些“脏活累活”？

这就是“模拟实现string类”这个项目的核心价值所在。它不是一个为了炫技的玩具，而是一个深入理解C++核心机制的绝佳训练场。通过亲手从零搭建一个MyString类，你将被迫直面并解决以下几个在C++开发中绕不开的“硬骨头”：内存的动态申请与释放、深拷贝与浅拷贝的抉择与实现、运算符重载的语法与语义、类设计中的“三大件”（构造函数、拷贝构造、赋值运算符），以及迭代器的初步概念。这些知识点不仅是面试官钟爱的“八股文”考点，更是你写出健壮、高效C++代码的基石。网络上充斥着大量关于string类用法的教程，但“知其然”更要“知其所以然”。模拟实现的过程，就是把你从“API调用者”转变为“底层设计者”的关键一步。无论你是为了夯实基础、备战面试，还是单纯对STL的实现感到好奇，这个项目都能让你获得远超预期的收获。

2. 整体设计与核心思路拆解

在动手写代码之前，我们必须先想清楚我们的MyString类应该长什么样，以及它需要遵循哪些设计原则。我们不能简单地照搬std::string的所有接口（那太庞大了），而是要抓住精髓，实现一个功能完整、逻辑清晰的简化版本。

2.1 类的数据成员设计

一个字符串类最核心的任务就是管理一段连续的内存来存放字符。因此，我们的数据成员至少需要三个：

1. char* _str: 一个指向动态分配内存的指针，用于存储字符串的字符内容，以\0结尾。
2. size_t _size: 记录当前字符串的实际长度（不包含末尾的\0）。
3. size_t _capacity: 记录当前已分配内存的总容量（通常大于或等于_size+1，为\0预留空间）。

为什么需要_capacity？这是为了优化性能。如果每次添加字符都重新分配内存，效率会极低。我们采用类似std::vector的“容量”策略，一次性分配一块更大的内存，只有在字符串长度超过当前容量时，才进行“扩容”操作。

2.2 需要实现的关键成员函数（“三大件”及析构）

这是类设计的灵魂，也是内存管理的核心区。

• 构造函数：负责对象的初始化。我们需要实现默认构造（创建一个空字符串）、用C风格字符串构造、用单个字符构造等。
• 拷贝构造函数：当用一个已存在的MyString对象初始化另一个新对象时（如MyString s2(s1);），它被调用。这里必须实现深拷贝，即为新对象独立分配内存并复制内容，避免两个对象的_str指向同一块内存。
• 赋值运算符重载 (operator=)：当对一个已存在的对象进行赋值时（如s2 = s1;），它被调用。这是最容易出错的地方之一。它需要处理自赋值（s1 = s1;）的情况，并且也要实现深拷贝。一个健壮的实现通常采用“拷贝后交换”(copy-and-swap)的技术。
• 析构函数：在对象生命周期结束时，负责释放动态申请的_str指向的内存，防止内存泄漏。

注意：深拷贝与浅拷贝的区别是这里的重中之重。浅拷贝只复制指针值，导致多个对象共享同一块内存，析构时会被重复释放，引发程序崩溃。深拷贝则是复制指针所指向的内容。

2.3 需要模拟的常用功能接口

为了让我们的MyString类实用，我们需要模拟实现一批最常用的std::string接口：

• 容量相关：size(),capacity(),empty(),clear(),reserve(size_t n)（扩容）,resize(size_t n, char ch)（调整大小）。
• 元素访问：operator[](size_t pos)（可读可写），at(size_t pos)（带边界检查），front(),back()。
• 修改操作：append,push_back,operator+=,insert,erase,replace。
• 字符串操作：c_str()（返回C风格字符串），find,substr。
• 非成员函数重载：流插入<<和流提取>>运算符，以及比较运算符（==,!=,<等）。

2.4 迭代器的简单模拟

完整的迭代器设计比较复杂，但我们可以做一个极简版的模拟：让begin()返回_str的指针，end()返回_str + _size的指针。这样就能支持基于范围的for循环（for(auto ch : str)），虽然它本质上还是指针，但已经具备了迭代器的雏形，有助于理解STL的设计思想。

3. 核心细节解析与实操要点

接下来，我们深入到几个最关键、最容易踩坑的细节实现中。我会结合代码片段和详细解释，说明为什么要这么做，以及有哪些隐藏的“坑”。

3.1 深拷贝的实现：拷贝构造与赋值运算符

这是模拟string类的“心脏”。我们先看一个错误的浅拷贝示例：

class MyString { public: char* _str; // ... 其他成员 // 错误的拷贝构造（编译器默认生成的就是类似这样的） MyString(const MyString& s) : _str(s._str), _size(s._size), _capacity(s._capacity) {} };

上面的代码只是复制了指针，导致s1和s2的_str指向同一块内存。当s1和s2析构时，同一块内存会被释放两次，程序必然崩溃。

正确的深拷贝实现（拷贝构造函数）：

MyString(const MyString& s) : _str(nullptr), _size(0), _capacity(0) { // 先判断源对象是否为空，避免对空指针操作 if (s._str) { _str = new char[s._capacity + 1]; // 多分配1个给\0 strcpy(_str, s._str); // 复制内容 _size = s._size; _capacity = s._capacity; } }

赋值运算符重载 (operator=) 的经典陷阱与“拷贝后交换”技法： 赋值运算符比拷贝构造更复杂，因为它需要处理一个已经存在的对象。一个朴素的做法是：

1. 释放当前对象自己的内存。
2. 根据源对象分配新内存并复制内容。
3. 复制_size和_capacity。

但这个做法有两个问题：1) 无法处理自赋值（s1 = s1;），在第一步释放内存后，源对象的内容也丢失了。2) 如果第二步new失败抛出异常，当前对象会处于一个已被破坏的状态（内存已释放但新内存未分配）。

更优雅、更安全的方法是“拷贝后交换” (Copy-and-Swap)：

MyString& operator=(MyString s) { // 注意！这里参数是值传递，会调用拷贝构造函数 swap(s); // 交换当前对象和临时对象s的内容 return *this; // 临时对象s在离开作用域时会析构，释放掉旧资源 } // 需要实现一个swap成员函数 void swap(MyString& s) { std::swap(_str, s._str); std::swap(_size, s._size); std::swap(_capacity, s._capacity); }

这个实现的精妙之处在于：

• 参数是值传递：MyString s会调用拷贝构造函数，生成源对象的一个完整副本。这个操作已经处理了自赋值（如果是自赋值，就是自己拷贝自己，完全正确）。
• 交换：然后我们交换当前对象和这个临时副本的所有成员。当前对象获得了新数据，临时副本持有了旧数据。
• 自动清理：函数结束时，临时副本s析构，自动释放了当前对象原来的内存。 这种方法异常安全，代码简洁，是现代C++中实现赋值运算符的推荐方式。

3.2 扩容策略：reserve 与 resize 的区分

reserve和resize是初学者容易混淆的两个函数。

• void reserve(size_t n):只增容量，不改变内容。它保证_capacity至少为n。如果n > _capacity，就重新分配一块大小为n的内存，把旧数据拷贝过去，然后释放旧内存。如果n <= _capacity，它什么都不做。它不会改变_size，也不会在新内存中初始化多余的部分。

  void reserve(size_t n) { if (n > _capacity) { char* newstr = new char[n + 1]; // +1 for '\0' if (_str) { strcpy(newstr, _str); delete[] _str; } _str = newstr; _capacity = n; // _size 保持不变！ } }

• void resize(size_t n, char ch = '\0'):改变大小，可能改变内容。它调整_size为n。

  • 如果n < _size，则直接截断，将_str[n]设为\0，_size = n。
  • 如果n > _size，则需要扩容（可能调用reserve），并将多出的位置（_str[_size]到_str[n-1]）用字符ch填充，最后在_str[n]位置设置\0，_size = n。

  void resize(size_t n, char ch = '\0') { if (n > _size) { if (n > _capacity) { reserve(n); // 或者 reserve(n * 2); 使用增长因子 } for (size_t i = _size; i < n; ++i) { _str[i] = ch; } } _str[n] = '\0'; _size = n; }

实操心得：在实现push_back或append时，我们通常先检查_size + 1是否超过_capacity（因为要多放一个字符和一个\0）。如果超过，就调用reserve进行扩容。一个常见的优化策略是倍增扩容（如reserve(_capacity == 0 ? 4 : _capacity * 2)），这能在时间效率和空间利用率之间取得很好的平衡，也是很多标准库容器的做法。

3.3 运算符重载的注意事项

重载运算符是为了让自定义类型用起来像内置类型一样直观。

• operator[]：需要提供const和非const两个版本。非const版本返回字符的引用，允许修改；const版本返回常量引用，用于const对象。

  char& operator[](size_t pos) { assert(pos < _size); // 使用断言进行边界检查，发布时可关闭 return _str[pos]; } const char& operator[](size_t pos) const { assert(pos < _size); return _str[pos]; }

• operator+=：通常返回自身的引用（MyString&），以支持链式调用（如s1 += s2 += s3;）。其内部实现可以复用append函数。
• 流运算符：operator<<和operator>>必须重载为全局函数（友元函数），因为它们的左操作数是流对象（std::ostream&），而不是我们的MyString对象。

  std::ostream& operator<<(std::ostream& out, const MyString& s) { out << s._str; // 或者 out << s.c_str(); return out; } std::istream& operator>>(std::istream& in, MyString& s) { // 简单实现：先清空s，然后逐个读取字符直到遇到空白符 s.clear(); char ch; ch = in.get(); while (ch != ' ' && ch != '\n' && ch != '\t') { s.push_back(ch); ch = in.get(); } return in; }

4. 完整模拟实现过程与核心代码剖析

下面，我将带领大家一步步实现一个简化但功能核心的MyString类。我们将遵循“先骨架，后血肉”的顺序。

4.1 类的声明与数据成员

首先，我们定义类的框架和私有成员。

// MyString.h #pragma once #include <iostream> #include <cassert> #include <cstring> // for strcpy, strlen, etc. namespace my { // 放入自己的命名空间，避免污染全局 class string { private: char* _str; // 指向存储字符串的动态数组 size_t _size; // 有效字符长度 size_t _capacity; // 总容量（不包含\0） static const size_t npos = -1; // 模仿标准库，表示未找到的位置 public: // 类型别名（为未来迭代器做准备） typedef char* iterator; typedef const char* const_iterator; // 构造函数系列 string(); string(const char* str); string(const string& s); // 拷贝构造 string(size_t n, char c); // 析构函数 ~string(); // 赋值运算符重载 string& operator=(string s); // 拷贝交换技法 // 迭代器相关（简化版） iterator begin() { return _str; } iterator end() { return _str + _size; } const_iterator begin() const { return _str; } const_iterator end() const { return _str + _size; } // 容量操作 size_t size() const { return _size; } size_t capacity() const { return _capacity; } bool empty() const { return _size == 0; } void clear(); void reserve(size_t n); void resize(size_t n, char ch = '\0'); // 元素访问 char& operator[](size_t pos); const char& operator[](size_t pos) const; const char* c_str() const { return _str ? _str : ""; } // 修改操作 void push_back(char ch); void append(const char* str); string& operator+=(const string& s); string& operator+=(const char* str); string& operator+=(char ch); void insert(size_t pos, const char* str); void insert(size_t pos, size_t n, char ch); void erase(size_t pos = 0, size_t len = npos); // 字符串操作 size_t find(char ch, size_t pos = 0) const; size_t find(const char* str, size_t pos = 0) const; string substr(size_t pos = 0, size_t len = npos) const; // 交换 void swap(string& s); private: // 内部工具函数，用于扩容检查 void _check_and_grow(size_t need); }; } // namespace my

4.2 构造函数与析构函数的实现

// MyString.cpp #include "MyString.h" namespace my { // 默认构造函数：创建一个空字符串 string::string() : _str(new char[1]), _size(0), _capacity(0) { _str[0] = '\0'; } // 用C风格字符串构造 string::string(const char* str) : _str(nullptr), _size(0), _capacity(0) { if (str) { _size = strlen(str); _capacity = _size; _str = new char[_capacity + 1]; strcpy(_str, str); } else { // 处理空指针，构造一个空字符串 _str = new char[1]; _str[0] = '\0'; } } // 拷贝构造函数（深拷贝） string::string(const string& s) : _str(nullptr), _size(0), _capacity(0) { if (s._str) { _str = new char[s._capacity + 1]; strcpy(_str, s._str); _size = s._size; _capacity = s._capacity; } else { _str = new char[1]; _str[0] = '\0'; } } // 用n个字符ch构造 string::string(size_t n, char c) : _str(nullptr), _size(n), _capacity(n) { _str = new char[_capacity + 1]; for (size_t i = 0; i < n; ++i) { _str[i] = c; } _str[n] = '\0'; } // 析构函数 string::~string() { delete[] _str; _str = nullptr; _size = _capacity = 0; } }

4.3 容量相关操作的实现

void string::clear() { if (_str) { _str[0] = '\0'; } _size = 0; // 注意：clear不释放内存，capacity保持不变 } void string::reserve(size_t n) { if (n > _capacity) { char* newstr = new char[n + 1]; if (_str) { strcpy(newstr, _str); delete[] _str; } else { newstr[0] = '\0'; } _str = newstr; _capacity = n; } } void string::resize(size_t n, char ch) { if (n <= _size) { // 缩小 _str[n] = '\0'; _size = n; } else { // 扩大 if (n > _capacity) { reserve(n); // 简单策略，直接扩到n } for (size_t i = _size; i < n; ++i) { _str[i] = ch; } _str[n] = '\0'; _size = n; } }

4.4 修改操作的关键实现（以push_back和append为例）

// 内部扩容检查函数（采用倍增策略） void string::_check_and_grow(size_t need) { if (need > _capacity) { size_t new_capacity = _capacity == 0 ? 4 : _capacity * 2; if (new_capacity < need) { new_capacity = need; } reserve(new_capacity); } } void string::push_back(char ch) { _check_and_grow(_size + 1); // 需要容纳_size+1个字符（含\0） _str[_size] = ch; ++_size; _str[_size] = '\0'; } void string::append(const char* str) { if (str == nullptr) return; size_t len = strlen(str); if (len == 0) return; _check_and_grow(_size + len); strcpy(_str + _size, str); // 从末尾开始拷贝 _size += len; // _str[_size] 已经在strcpy时被设置为\0 } string& string::operator+=(const string& s) { append(s._str); return *this; } // ... 其他+=重载类似

4.5 查找与子串操作实现

size_t string::find(char ch, size_t pos) const { if (pos >= _size) return npos; const char* result = strchr(_str + pos, ch); return result ? result - _str : npos; } size_t string::find(const char* str, size_t pos) const { if (pos >= _size || str == nullptr) return npos; const char* result = strstr(_str + pos, str); return result ? result - _str : npos; } string string::substr(size_t pos, size_t len) const { if (pos >= _size) { return string(); // 返回空字符串 } // 计算实际要拷贝的长度 size_t real_len = len; if (len == npos || pos + len > _size) { real_len = _size - pos; } string sub; sub.reserve(real_len); for (size_t i = 0; i < real_len; ++i) { sub.push_back(_str[pos + i]); } return sub; }

4.6 全局运算符重载实现

// 在MyString.cpp文件末尾，命名空间外或内 namespace my { bool operator==(const string& lhs, const string& rhs) { return strcmp(lhs.c_str(), rhs.c_str()) == 0; } bool operator!=(const string& lhs, const string& rhs) { return !(lhs == rhs); } bool operator<(const string& lhs, const string& rhs) { return strcmp(lhs.c_str(), rhs.c_str()) < 0; } // ... 其他比较运算符类似 std::ostream& operator<<(std::ostream& out, const string& s) { out << s.c_str(); return out; } std::istream& operator>>(std::istream& in, string& s) { s.clear(); // 先清空目标字符串 char ch; ch = in.get(); // 跳过前导空白符（标准库行为） while (ch == ' ' || ch == '\n' || ch == '\t') { ch = in.get(); } // 读取直到遇到空白符 while (ch != ' ' && ch != '\n' && ch != '\t' && ch != EOF) { s.push_back(ch); ch = in.get(); } // 如果是因为EOF结束，需要把EOF放回流中吗？通常不需要。 return in; } } // namespace my

5. 常见问题、调试技巧与避坑指南实录

在模拟实现的过程中，我踩过不少坑，也调试过许多奇怪的错误。这里把一些典型问题和排查思路记录下来，希望能帮你节省时间。

5.1 内存问题：访问越界、内存泄漏与重复释放

这是最常见的一类问题，通常由指针操作失误引起。

• 症状：程序运行时崩溃（Segmentation fault），或在退出时崩溃，或使用Valgrind等工具检测出内存错误。
• 排查点：
  1. 所有[]运算符访问和at函数：确保下标pos < _size。在调试版本中，使用assert(pos < _size)进行断言。
  2. 所有strcpy,strcat等C字符串函数：确保目标缓冲区（_str）有足够的空间（_capacity），并且源字符串是有效的（非空指针且以\0结尾）。在append、insert等函数中，务必在操作前调用_check_and_grow。
  3. 构造函数和reserve：分配内存时，大小是_capacity + 1，别忘了给\0留位置。
  4. 拷贝构造和赋值运算符：这是重复释放的重灾区。务必实现深拷贝。使用“拷贝后交换”技法能极大降低出错概率。
  5. 析构函数：确保使用delete[] _str，而不是delete _str。因为_str是通过new char[]分配的数组。
• 实操心得：养成“分配与释放配对”的思维习惯。每次new[]都要想好在哪里delete[]。对于指针成员，在构造函数中初始化为nullptr，在析构函数中释放前检查是否为nullptr（delete[] nullptr是安全的），这是一个好习惯。

5.2 迭代器失效问题

我们的简化版迭代器（就是指针）也会失效，主要发生在修改字符串内容的操作之后。

• 场景：在push_back、append、insert、erase、reserve等操作中，如果触发了内存重新分配（realloc），那么之前获取的所有迭代器（包括begin()、end()返回的，以及通过它们得到的指针）、引用和指针都将失效，因为它们指向的是已经被释放的旧内存。
• 示例：

  my::string s = “hello”; char* it = s.begin(); // it 指向 ‘h’ s.append(“world, this is a long string that may cause reallocation”); std::cout << *it << std::endl; // 危险！it可能已经悬空

• 规避方法：在可能引发扩容的操作之后，避免使用之前保存的迭代器/指针/引用。如果需要遍历并修改，可以考虑使用下标[]，或者在修改后重新获取迭代器。

5.3 自赋值与异常安全

这是赋值运算符operator=必须处理的经典问题。

• 自赋值测试：一定要测试s = s;是否正常工作。朴素的“先释放再分配”实现会在自赋值时崩溃。“拷贝后交换”技法则天然正确处理了自赋值。
• 异常安全：考虑在new内存时可能抛出std::bad_alloc异常。“拷贝后交换”技法提供了强异常安全保证：如果拷贝构造失败（抛出异常），赋值操作根本不会发生，当前对象状态保持不变。

5.4 测试用例设计

编写全面的测试用例是验证实现正确性的关键。你应该至少覆盖以下场景：

调试技巧：在关键函数（如构造、析构、reserve、赋值）的开始和结束处打印日志，观察内存地址(_str)的变化，对于理解深拷贝、扩容过程非常有帮助。使用调试器（如GDB或VS调试器）设置断点，单步跟踪程序的执行，是定位复杂逻辑错误的终极武器。

亲手实现一遍string类，虽然只是一个简化版，但其过程犹如一次对C++面向对象和内存管理的深度解剖。你会对“资源获取即初始化”(RAII)思想有切身体会，会对指针和内存保持前所未有的警惕，也会深刻理解STL设计背后的权衡与智慧。当你再回头使用std::string时，那种感觉不再是面对一个黑盒魔法，而是与一个老友重逢，你知道它的脾气，也清楚它的能力边界。这份从底层构建起来的理解，是阅读任何高级教程都无法替代的扎实基础。