企业官网建设流程全解析

今天来聊聊C++里一个绕不开的话题——string的增删查改模拟实现。很多学C++的同学都会有这种感觉：std::string用起来挺顺手，但一旦让你自己动手实现一个，立刻就会卡住。不是不知道该有哪些接口，而是当你在构造函数里分配内存、在拷贝构造里思考怎么处理指针时，你才真正开始理解C++的内存管理。这篇文章就把这件事说透：从一个最简单的char*开始，一步步用C++实现一个支持增删查改的MiniString类，讲清楚每个接口背后的设计思路、踩坑点和优化手段。

为什么值得写这样一篇东西？因为string看似简单，实际是C++里最能考察基本功的类之一。深拷贝与浅拷贝、动态内存管理、运算符重载、迭代器语义、容量增长策略，这些面试八股里的高频考点，在模拟实现string的过程中全都能碰到。你把这一个类从头到尾写干净了，再去看vector、list的模拟实现，会发现很多套路是相通的。适合正在学习C++的同学、准备面试的求职者，以及想加深对STL理解的一线开发。

1. 动手前先想清楚：为什么要手写一个string

1.1 面试八股背后的真实价值

很多人觉得模拟实现string是面试官故意刁难人，实际工作中直接std::string不就行了？话是没错，但如果你从来没自己实现过一个管理动态内存的类，你对底层机制的理解就永远是黑盒。

我给你举个真实例子。有一次我看一位候选人写深拷贝的代码，他写的拷贝构造是这样的：

MyString(const MyString& s) : _str(s._str) // 浅拷贝，直接让指针指向同一块内存 {}

问他这样有什么问题？他说"没问题啊，反正字符串内容一样"。结果我追问了一句：两个对象析构的时候会发生什么？他才反应过来——同一块内存被释放两次，直接double free崩溃。

这就是为什么模拟实现有价值。只有亲手写过析构函数、亲自踩过浅拷贝的坑，你才能真正理解"一个类管理了堆资源，就必须实现拷贝构造、赋值重载和析构"这条规则。这不是背出来的，是试错试出来的。

1.2 你需要实现哪些核心功能

模拟实现不是要把std::string的上百个接口全部抄一遍，那不现实也没必要。一个能说明问题的实现，至少需要覆盖这几块：

一是生命周期管理：默认构造、带const char*参数的构造、拷贝构造、析构、拷贝赋值。这一块的核心是正确管理动态内存，杜绝浅拷贝。

二是容量管理：size()返回有效字符个数，capacity()返回当前容量，reserve()预留空间，resize()调整有效长度。这四兄弟是理解string扩容机制的钥匙。

三是增删查改操作：push_back()尾部追加单字符，append()追加字符串，insert()在指定位置插入，erase()删除指定区间，find()查找子串，operator[]访问元素，c_str()返回C风格字符串。这些就是标题里说的"增删查改"。

四是现代C++的优化：移动构造和移动赋值。虽然初学者可以先把这块放一放，但既然要写，写出来能让整个类在vector、其他容器里使用时的性能好一个档次。

我把这些整理成一张简化版接口表，你写代码之前心里先有个谱：

2. 基础设施：类的骨架与三大件

2.1 成员变量与构造析构设计

写这个类，第一步是定成员变量。我的习惯是很朴素的三件套：

class MyString { public: // 各种成员函数 private: char* _str; // 指向动态分配的字符数组 size_t _size; // 有效字符个数，不含'\0' size_t _capacity; // 当前缓冲区容量，不含'\0' };

有的教科书喜欢用capacity表示包括'\0'在内的总空间，两种约定都行，但必须前后一致。我自己习惯在容量里不包含结尾的'\0'，因为这样reserve(10)就明确表示能容纳10个有效字符，更贴近使用直觉。如果你把'\0'也算进去，reserve(10)实际能存9个字符，容易在边界条件上绕晕。

构造函数怎么写有讲究。默认构造和带参构造建议统一走一个底层函数，避免大量重复代码：

MyString(const char* str = "") : _str(nullptr), _size(0), _capacity(0) { if (str == nullptr) { str = ""; } _size = strlen(str); _capacity = _size; _str = new char[_capacity + 1]; // +1给'\0'留位置 strcpy(_str, str); }

这里有个我踩过的坑：strcpy会把源字符串的'\0'一并拷贝过去，所以分配空间时一定要想清楚strlen返回的长度和实际拷贝需要的字节数之间的关系。strlen("abc")返回3，但"abc"在内存里实际占4字节，因为结尾有'\0'。所以new char[_capacity + 1]是必须的。

析构就很简单了，把堆内存还回去就行：

~MyString() { delete[] _str; _str = nullptr; _size = _capacity = 0; }

有人问为什么要置nullptr？析构之后对象生命周期就结束了，那是为了调试方便。如果你在析构里打印日志或者之后又误调用某些接口，一个非空的野指针会误导你，置空之后还能让其他代码不至于拿到一个"看起来有效"的地址。

2.2 深浅拷贝的坑：为什么必须写拷贝构造和赋值

这是整个模拟实现里最重要的一个点，我建议你停下来想明白再往下写。

如果没有自定义拷贝构造，编译器会生成一个逐成员拷贝的默认版本。对于指针成员，逐成员拷贝意味着两个对象的_str指向同一块内存。这是浅拷贝，后果是把解决问题的时间全部花在调试崩溃上。

我给你画一下场景。假设有a和b两个MyString对象，a里面存储着"hello"，然后执行MyString b(a)。浅拷贝之后，b._str = a._str，两块内存共享。程序结束时会依次调用析构函数，b先析构，delete[]掉了那块内存；接着a析构，再次delete[]同一个地址，就成了double free。哪怕不崩溃，如果你修改b的内容，a也会跟着变，因为本质上是同一块内存。

正确的写法是深拷贝——重新开辟一块内存，把内容复制过去：

MyString(const MyString& s) { _size = s._size; _capacity = s._capacity; _str = new char[_capacity + 1]; strcpy(_str, s._str); // 或者用memcpy也行 }

拷贝赋值重载同理，但有三个细节必须处理：

第一，检测自赋值。如果写成s = s自己，先释放旧内存再拷贝，旧内存已经没了，后面拷贝的就是野指针，直接崩。

第二，先开新空间再释放旧空间。这是异常安全的基本素养，万一new抛异常，原对象还保持原状。你如果先delete掉旧内存再new，new抛出异常时对象已经处于内存泄漏的中间状态。

第三，赋值要处理已有资源。别人的_size是10，你这个对象里可能已经有5个字符了，不释放旧空间就是内存泄漏。

我惯用的写法是copy-and-swap风格，代码逻辑清晰：

void swap(MyString& tmp) noexcept { std::swap(_str, tmp._str); std::swap(_size, tmp._size); std::swap(_capacity, tmp._capacity); } MyString& operator=(const MyString& s) { if (this != &s) { MyString tmp(s); // 调用拷贝构造，完成深拷贝 swap(tmp); // 交换后，旧资源由tmp在析构时释放 } return *this; }

这套写法的妙处在于：深拷贝交给拷贝构造，资源释放交给tmp的析构，本身不用手动管理新旧内存的接替。它天然处理了自赋值，因为自赋值时tmp是同一个对象的深拷贝，交换后两边数据仍是原来的值，不会出问题。

2.3 高效扩容：reserve与capacity的倍增策略

string底层是一个动态字符数组，append、insert、push_back都要先确认容量够不够。如果每次追加一个字符就重新new一次，那性能就是灾难。std::string的容量是增长的，而且通常是翻倍增长，因为这样可以保证均摊时间复杂度为O(1)。

模拟实现时，reserve和扩容函数要分开写。reserve是用户主动申请空间，扩容函数是内部自动触发的。我建议把"确保容量足够"封装成一个私有函数：

void reserve(size_t newCapacity) { if (newCapacity > _capacity) { char* newStr = new char[newCapacity + 1]; if (_str) { strcpy(newStr, _str); } delete[] _str; _str = newStr; _capacity = newCapacity; } } void ensureCapacity(size_t requireSize) { if (requireSize > _capacity) { size_t newCap = _capacity == 0 ? 4 : _capacity * 2; while (newCap < requireSize) { newCap *= 2; } reserve(newCap); } }

我特意把newCapacity == 0的情况考虑进去，初始容量设为4而不是1，因为实际使用时字符串很少只有一个字符，4能减少一部分扩容频率。倍增、减半这套策略敲定之后，你在push_back或insert的时候只需要调ensureCapacity就行，不用每次关心到底分配多少。

3. 核心增删查改如何一步步实现

3.1 增：push_back、append与insert的实现细节

增操作是整个模拟实现里最容易互相触发bug的地方，因为插入会移动数据，还要维护'\0'的正确位置。

push_back是最简单的，追加单个字符到尾部：

void push_back(char ch) { ensureCapacity(_size + 1); _str[_size] = ch; _str[_size + 1] = '\0'; // 新结尾 _size++; }

注意顺序：先写字符，再写'\0'，最后增加_size。如果先_size++再写，下标就要写成_size-1，容易出错。我习惯把这个顺序固定成"先写数据后改尺寸"。

append的实现跟拷贝构造很类似，核心是把源字符串拼接进来：

MyString& append(const char* str) { size_t len = strlen(str); ensureCapacity(_size + len); strcpy(_str + _size, str); _size += len; return *this; }

这里有个很隐蔽很恶心的坑：如果str指向的是当前对象内部的缓冲区，比如myStr.append(myStr._str)或者类似自拼接的场景，就会发生内存重叠。ensureCapacity里一旦扩容，内部缓冲区的地址就变化了，但str还指向旧地址，同时旧缓冲区已被delete，str变成野指针。你直接调std::string的append都不见得能处理好每个这种case，所以模拟实现可以不彻底解决，但至少要意识到这个风险，在注释里写明。

insert是增操作里最复杂的，因为它要移动元素。我的思路分三步：扩容量、后移区间、插入新数据。以单字符插入为例：

void insert(size_t pos, char ch) { assert(pos <= _size); // 允许在末尾插入，但不允许越界 ensureCapacity(_size + 1); // 把[pos, _size)区间的字符整体后移一位 for (size_t i = _size; i > pos; i--) { _str[i] = _str[i - 1]; } _str[pos] = ch; _size++; _str[_size] = '\0'; }

后移要特别注意循环方向。从后往前移动，否则会把还没移动过的字符覆盖掉。我做面试官的时候，会特意关注候选人写的是从前往后还是从后往前，这是基本功的试金石。

插入字符串也是同样的套路，只不过后移的步长是len：

void insert(size_t pos, const char* str) { size_t len = strlen(str); assert(pos <= _size); ensureCapacity(_size + len); // 先移动原字符串的尾部，再拷贝插入内容 for (size_t i = _size; i > pos; i--) { _str[i + len - 1] = _str[i - 1]; } for (size_t j = 0; j < len; j++) { _str[pos + j] = str[j]; } _size += len; _str[_size] = '\0'; }

写完这两个函数，你的MyString已经能实打实地增了。但也提醒一句：insert后所有对字符串buffer的指针引用都会失效，因为可能扩容重新分配了内存，这是使用层面的常见坑，不是实现层面的。

3.2 删：erase与clear的注意事项

删操作相比增操作要简单一些，但它不代表没坑。

erase的语义是删除从pos位置开始的len个字符。如果len太大，只能删到字符串末尾。判断越界的标准是pos > _size才异常，而不是pos + len > _size。我见过不少野路子实现直接让pos + len决定是否越界，导致本来合法的调用抛了异常。

void erase(size_t pos, size_t len = npos) { assert(pos < _size); // 删除位置必须有效 if (len == npos || pos + len >= _size) { // 一直删到末尾 _str[pos] = '\0'; _size = pos; return; } // 把[pos+len, _size)的字符搬到pos位置 size_t remain = _size - pos - len; memmove(_str + pos, _str + pos + len, remain + 1); // 连'\0'一起搬 _size -= len; }

这里用memmove而不是memcpy，是因为源和目的区间可能重叠，memmove能正确处理重叠情况。正宗的std::string内部也是这么干的，这算是一个性能细节。

clear的实现非常简单，直接把大小归零并写上'\0'就好：

void clear() { if (_str) { _str[0] = '\0'; } _size = 0; }

有个小地方要提醒：clear之后capacity是不变的，也就是说你不会因为clear而释放内存，下次继续append不会经历扩容。这其实是好事，std::string也是这么做的。有些初学者觉得clear应该把内存也释放掉，我不建议这样做，因为频繁地clear再追加是常见模式，每次都释放再分配会性能骤降。

pop_back就不用多说了，尾部弹出一个字符，把_size减一，然后在新尾部写'\0'。注意检查是否为空，空字符串上调用pop_back应该是未定义行为——我在自己的实现里会加个assert(_size > 0)。

3.3 查：find与operator[]的高效姿势

查操作有两个层次，一个是随机访问，一个是查找子串。

operator[]是返回非常量的引用，所以允许用户直接修改指定位置的字符。最直接的实现是：

char& operator[](size_t pos) { assert(pos < _size); return _str[pos]; }

你可能会问，为什么不是直接返回_str[pos]就完事了，还需要assert？因为下标访问在整个STL里是"不检查边界"的操作，越界访问结果未定义。但在模拟实现里加一个assert能在调试阶段帮你拦下一堆低级错误，发布时还可以通过NDEBUG宏自动关掉，成本几乎为零。

const版本也要写，否则const对象无法通过const MyString&访问元素：

const char& operator[](size_t pos) const { assert(pos < _size); return _str[pos]; }

find的实现是朴素的暴力匹配。对于一个小型精简string来说，没必要上KMP或者BM，除非你要处理特别长的文本。我写的find支持从指定位置开始查找：

size_t find(const char* sub, size_t pos = 0) const { size_t subLen = strlen(sub); if (pos >= _size || subLen == 0 || _size - pos < subLen) { return npos; } for (size_t i = pos; i <= _size - subLen; i++) { size_t j = 0; while (j < subLen && _str[i + j] == sub[j]) { j++; } if (j == subLen) { return i; } } return npos; }

我遇到的常见操作是把find的结果跟npos比较。一个合理的npos值可以定义为static const size_t npos = (size_t)-1，也就是size_t能表示的最大值，这样任何合法的下标都不可能等于npos。

还有c_str()，它的行为是返回内部缓冲区的指针，正常情况下一定以'\0'结尾。这就是为什么我们在所有增删操作里都要保证末尾有个'\0'，否则c_str()就变成了一颗定时炸弹，外部以为它是合法的C字符串，实际内存早已越界读取。

3.4 改：replace与assign

改操作我分两类来谈。一类是replace替换子串，另一类是assign整体重新赋值。

replace最常见的形态是：替换[pos, pos+len)区间的内容为另一个字符串。实现思路和我前面讲insert类似，唯一的区别是要处理"新串长度与旧串长度不一样"时的数据搬移：

MyString& replace(size_t pos, size_t len, const char* str) { assert(pos < _size); size_t newLen = strlen(str); // 先计算替换后的总长度 size_t oldPartLen = _size - pos - len; // 被替换区间之后的长度 if (pos + len > _size) { oldPartLen = 0; len = _size - pos; } // 保证容量足够 size_t newSize = pos + newLen + oldPartLen; ensureCapacity(newSize); // 把区间之后的内容搬到新位置 if (oldPartLen > 0) { memmove(_str + pos + newLen, _str + pos + len, oldPartLen + 1); } // 写入新串 for (size_t i = 0; i < newLen; i++) { _str[pos + i] = str[i]; } _size = newSize; _str[_size] = '\0'; return *this; }

replace这种操作最麻烦的就是"保留尾部内容"这件事。你的替换区间和保留区间可能重叠，也可能不重叠，直接用memmove能一并处理好。

assign就简单太多了，它的语义相当于一个加强版的赋值操作，把当前对象的内容整个替换成别的字符串：

MyString& assign(const char* str) { size_t len = strlen(str); // 如果现有容量足够，直接复用缓冲区 if (len <= _capacity) { strcpy(_str, str); _size = len; } else { // 容量不够时才重新分配 MyString tmp(str); swap(tmp); } return *this; }

assign的设计思路是：能复用缓冲就复用，不能复用才重新分配。这样可以让用户频繁地给同一个字符串变量赋不同的值而不会反复new/delete，性能和内存碎片都更好。

4. 现代C++的优化：移动语义与右值引用

4.1 为什么移动拷贝和移动赋值能省一次深拷贝

如果你是在C++11之后的编译器上编译，建议把移动构造和移动赋值也加上。它的核心原理是：当用一个右值（比如临时对象）去构造或赋值时，源对象马上就会被销毁，这时候再开一块内存去做深拷贝纯属浪费，不如直接把源对象的资源抢过来，再把源对象置成空状态。

以移动构造为例：

MyString(MyString&& s) noexcept : _str(s._str), _size(s._size), _capacity(s._capacity) { s._str = nullptr; s._size = 0; s._capacity = 0; }

这里没有任何拷贝，只是搬了三个成员变量的值，然后让s内部的指针不再指向那块内存。这样s析构时不会delete掉那块已经属于新对象的缓冲区。这就是移动语义省下的那次深拷贝。

移动赋值差不多，但要点是先把当前对象已有的资源释放掉，再接管新资源：

MyString& operator=(MyString&& s) noexcept { if (this != &s) { delete[] _str; // 释放自己原来的内存 _str = s._str; // 接管s的资源 _size = s._size; _capacity = s._capacity; s._str = nullptr; // 把s置空 s._size = 0; s._capacity = 0; } return *this; }

我个人的经验是：一旦实现移动构造，拷贝构造函数最好改成以值传递接收参数的形态，或者直接提供两个版本的swap来优化。不过这是一个大改动，需要配合测试来验证，否则容易顾此失彼。

4.2 完整模拟实现代码示例

这里给出一个浓缩版的完整实现，把前面讲的几个部分串起来。我特意把一些隐患性的细节在注释里标出来了，后续你可以在这个基础上加接口。

#include <iostream> #include <cstring> #include <cassert> #include <cstddef> class MyString { public: static const size_t npos = (size_t)-1; MyString(const char* str = "") : _str(nullptr), _size(0), _capacity(0) { if (str == nullptr) { str = ""; } _size = strlen(str); _capacity = _size; _str = new char[_capacity + 1]; strcpy(_str, str); } MyString(const MyString& s) : _str(nullptr), _size(s._size), _capacity(s._capacity) { _str = new char[_capacity + 1]; strcpy(_str, s._str); } MyString(MyString&& s) noexcept : _str(s._str), _size(s._size), _capacity(s._capacity) { s._str = nullptr; s._size = s._capacity = 0; } ~MyString() { delete[] _str; } MyString& operator=(const MyString& s) { if (this != &s) { MyString tmp(s); swap(tmp); } return *this; } MyString& operator=(MyString&& s) noexcept { if (this != &s) { delete[] _str; _str = s._str; _size = s._size; _capacity = s._capacity; s._str = nullptr; s._size = s._capacity = 0; } return *this; } void swap(MyString& s) noexcept { std::swap(_str, s._str); std::swap(_size, s._size); std::swap(_capacity, s._capacity); } size_t size() const { return _size; } size_t capacity() const { return _capacity; } bool empty() const { return _size == 0; } const char* c_str() const { return _str ? _str : ""; } char& operator[](size_t pos) { assert(pos < _size); return _str[pos]; } const char& operator[](size_t pos) const { assert(pos < _size); return _str[pos]; } private: void reserve(size_t newCapacity) { if (newCapacity > _capacity) { char* newStr = new char[newCapacity + 1]; if (_str) { strcpy(newStr, _str); } delete[] _str; _str = newStr; _capacity = newCapacity; } } void ensureCapacity(size_t requireSize) { if (requireSize > _capacity) { size_t newCap = _capacity == 0 ? 4 : _capacity * 2; while (newCap < requireSize) { newCap *= 2; } reserve(newCap); } } public: void push_back(char ch) { ensureCapacity(_size + 1); _str[_size] = ch; _str[_size + 1] = '\0'; _size++; } MyString& append(const char* str) { size_t len = strlen(str); ensureCapacity(_size + len); strcpy(_str + _size, str); _size += len; return *this; } MyString& operator+=(const char* str) { return append(str); } MyString& operator+=(char ch) { push_back(ch); return *this; } void insert(size_t pos, char ch) { assert(pos <= _size); ensureCapacity(_size + 1); for (size_t i = _size; i > pos; i--) { _str[i] = _str[i - 1]; } _str[pos] = ch; _size++; _str[_size] = '\0'; } void insert(size_t pos, const char* str) { assert(pos <= _size); size_t len = strlen(str); ensureCapacity(_size + len); for (size_t i = _size; i > pos; i--) { _str[i + len - 1] = _str[i - 1]; } for (size_t j = 0; j < len; j++) { _str[pos + j] = str[j]; } _size += len; _str[_size] = '\0'; } void erase(size_t pos, size_t len = npos) { assert(pos < _size); if (len == npos || pos + len >= _size) { _str[pos] = '\0'; _size = pos; return; } size_t remain = _size - pos - len; memmove(_str + pos, _str + pos + len, remain + 1); _size -= len; } void clear() { if (_str) { _str[0] = '\0'; } _size = 0; } void pop_back() { assert(_size > 0); _size--; _str[_size] = '\0'; } size_t find(const char* sub, size_t pos = 0) const { size_t subLen = strlen(sub); if (pos >= _size || subLen == 0 || _size - pos < subLen) { return npos; } for (size_t i = pos; i <= _size - subLen; i++) { size_t j = 0; while (j < subLen && _str[i + j] == sub[j]) { j++; } if (j == subLen) { return i; } } return npos; } MyString& replace(size_t pos, size_t len, const char* str) { assert(pos < _size); size_t newLen = strlen(str); size_t oldPartLen = 0; if (pos + len >= _size) { len = _size - pos; // 替换到末尾 } else { oldPartLen = _size - pos - len; } size_t newSize = pos + newLen + oldPartLen; ensureCapacity(newSize); if (oldPartLen > 0) { memmove(_str + pos + newLen, _str + pos + len, oldPartLen + 1); } for (size_t i = 0; i < newLen; i++) { _str[pos + i] = str[i]; } _size = newSize; _str[_size] = '\0'; return *this; } private: char* _str; size_t _size; size_t _capacity; };

给几个简单的测试验证一下：

void testBasic() { MyString s1("hello"); assert(strcmp(s1.c_str(), "hello") == 0); assert(s1.size() == 5); MyString s2(s1); // 拷贝构造 assert(strcmp(s2.c_str(), "hello") == 0); // 修改s2，s1不应受影响 s2[0] = 'H'; assert(strcmp(s1.c_str(), "hello") == 0); assert(strcmp(s2.c_str(), "Hello") == 0); s1.push_back('!'); assert(strcmp(s1.c_str(), "hello!") == 0); s1.insert(5, "world"); assert(strcmp(s1.c_str(), "helloworld!") == 0); s1.erase(5, 5); assert(strcmp(s1.c_str(), "hello!") == 0); assert(s1.find("lo", 0) == 3); assert(s1.find("xyz") == MyString::npos); s1.replace(1, 2, "ELL"); assert(strcmp(s1.c_str(), "hELLo!") == 0); MyString s3; s3 = s1; // 拷贝赋值 assert(strcmp(s3.c_str(), "hELLo!") == 0); std::cout << "all test passed" << std::endl; }

如果这段测试跑起来没有一个断言挂掉，你的模拟实现基本就是能用的了。

5. 常见问题与调试经验

5.1 运行崩溃的排查看这里：浅拷贝、越界、迭代器失效

我自己在指导别人写这个类的时候，最常见的问题集中在三个地方。

第一个就是浅拷贝。症状是崩溃时机很随机，有时候不是当场崩，而是在函数返回之后崩。排查技巧是：在析构函数里打印一条日志，然后创建两个对象进行拷贝，看析构是否被调用了两次并且地址相同。如果日志里输出两个相同的delete地址，基本可以断定是浅拷贝。

第二个是越界访问。很多同学只记得new char[len]，忘了还要给'\0'留位置，结果c_str()在读越界的'\0'时踩到未分配内存。这种问题在gcc下往往不崩，在MSVC的debug下狂报警告。稳妥的做法是把所有读尾部的逻辑都走一遍，确保写'\0'的下标不超过capacity。

第三个是迭代器失效的隐患。这个在模拟实现里主要体现在：任何可能扩容的操作（push_back、append、insert、replace）之后，之前通过c_str()或&str[0]拿到的指针都会失效。我给你一个特别容易踩的场景：

const char* p = s.c_str(); s.append(" more"); // 此刻p指向的内存可能已经被释放

这不是你实现的问题，而是使用层面的语义。但既然你在模拟实现，文档和注释里写清楚这一点，会显得你考虑问题很全面。

5.2 reserve、resize和insert的边界坑

reserve和resize是容易混的两个接口。我的经验是用一句话区分：reserve只改容量不改大小，resize改大小还会初始化新字符。reserve(20)之后size()还是原来的值，只是后续append不用扩容而已。resize(20)则会真正让字符串变成20个字符，新增部分可以是'\0'或者指定字符。

如果你在实现resize的时候，遇到缩小的情况，只是把_size改了就行，但记得在新末尾写'\0'。遇到扩大的情况，可以复用ensureCapacity，然后再补字符：

void resize(size_t newSize, char ch = '\0') { if (newSize <= _size) { _size = newSize; if (_str) { _str[_size] = '\0'; } } else { ensureCapacity(newSize); for (size_t i = _size; i < newSize; i++) { _str[i] = ch; } _size = newSize; _str[_size] = '\0'; } }

insert边界上的坑是pos == _size，这个调用在逻辑上是合法的，相当于在末尾追加。我在许多模拟实现里看到assert(pos <= _size)，这没问题，但如果你只写了assert(pos < _size)，那insert到末尾就会失败。一定要想清楚是小于还是小于等于。

5.3 测试驱动：怎么验证你的string实现是对的

编写测试是很多自学的人容易忽略的环节，但这恰恰是模拟实现最有价值的部分。测试不能只测正常流程，要把边界情况都覆盖到。

我的测试清单一般包含这些：

空字符串操作：默认构造后调用size()、c_str()、empty()、find，都不应崩溃。尤其是c_str()，空字符串也必须返回一个以'\0'结尾的合法地址。

单字符字符串：push_back到空串第一次扩容，要验证扩容后旧数据是否被正确拷贝。

大量追加：连续push_back50000个字符，然后用c_str()验证内容完整。这一步能测试出扩容策略是否正确，如果扩容时少拷贝了'\0'，最后读到的字符串会多出奇怪字符。

自赋值：s = s这种写法虽不推荐，但必须验证它不崩溃且数据不丢失。

find无匹配：确保返回npos，并且不会越界访问。

insert在头部和尾部：头插会移动所有字符，尾插相当于append，两种都必须正确。

erase全部和部分：erase到末尾时len传npos，erase中间区间时，验证后缀能正确前移。

这些测试写下来，即使你的实现有小bug，调试起来也快得多。

6. 写在最后：模拟实现的真正收获

把整个MyString写下来之后，我最大的体会是：代码本身并不长，但每一行都踩在C++内存管理的关键点上。你在学习std::string的时候，看到的是接口的便利；但当你自己实现的时候，看到的是new与delete的对称、浅拷贝与深拷贝的代价、扩容与数据搬移的权衡。

按照我个人的经验，建议你写完这个类之后做三件扩展练习：

第一，加一个插入字符串的operator+=版本，比如支持MyString + const char*的运算符重载，练习返回新对象的写法。第二，把find升级成支持从尾部查找的rfind，可以顺带熟悉反向遍历。第三，尝试给这个类增加一个采用小字符串优化（SSO）的版本——当字符串很短时直接用栈上数组存储，只有当长度超过阈值时才转到堆上分配。这个优化机制在很多标准库实现里都存在，模拟一遍能更深刻理解STL内部如何平衡性能与内存。

最后一个真实建议：写完后一定要用Sanitizer跑一遍。在编译时加上-fsanitize=address，然后运行你的测试代码，它会帮你抓出所有内存越界和释放后使用的问题。我的实践经验是，一个初版模拟实现极少能在address sanitizer下一次通过，大概率会有几处隐藏的越界读写，这恰好就是你理解C++内存模型的最好机会。

这篇文章到这就该收尾了。我最后再分享一个小技巧：把这份代码保存下来，过两周再回头看一遍，如果你不看源代码就能重新默写出来，并且能解释每个成员函数为什么这样写，那你对C++动态内存管理的理解就已经到了一个新的层级。别只收藏，动手写才是正经事。