C++字符串操作：模拟实现string增删查改-平芜编程栈

1. 为什么需要模拟实现string的增删查改？

在C++开发中，string是最基础也最常用的数据类型之一。标准库提供的string类虽然功能完善，但直接使用黑箱式的库函数不利于我们深入理解字符串操作的底层原理。通过手动实现string的增删查改功能，可以让我们：

掌握动态内存管理的核心技巧
理解字符串操作的时间复杂度
培养编写安全、高效代码的习惯
为面试中常见的数据结构问题打下基础

我曾在多个C++项目中处理过复杂的字符串操作，发现很多看似简单的功能（如字符串拼接）如果实现不当，会导致严重的内存问题。下面我将分享一个经过实战检验的string实现方案。

2. 基础结构设计与内存管理

2.1 类的基本框架

我们先定义一个简易的MyString类：

class MyString { public: // 构造函数与析构函数 MyString(const char* str = ""); ~MyString(); // 增删查改接口 void append(const char* str); void insert(size_t pos, const char* str); void erase(size_t pos, size_t len); size_t find(const char* str) const; char& operator[](size_t idx); private: char* m_data; // 字符串数据 size_t m_size; // 当前长度 size_t m_capacity; // 总容量 };

2.2 内存分配策略

高效的string实现关键在于内存管理。我们采用"预分配+按需扩容"的策略：

初始分配一定容量（如16字节）
当需要扩容时，按当前容量1.5倍增长
每次操作后维护m_size和m_capacity的正确性

提示：1.5倍增长是STL常用策略，在空间利用和性能间取得平衡

扩容的典型实现：

void MyString::reserve(size_t new_capacity) { if (new_capacity <= m_capacity) return; char* new_data = new char[new_capacity + 1]; // +1 for '\0' strcpy(new_data, m_data); delete[] m_data; m_data = new_data; m_capacity = new_capacity; }

3. 核心操作实现详解

3.1 增加操作（append/insert）

追加字符串的实现要点：

void MyString::append(const char* str) { size_t len = strlen(str); if (m_size + len > m_capacity) { reserve(max(m_size + len, m_capacity * 1.5)); } strcpy(m_data + m_size, str); m_size += len; }

插入操作的注意事项：

边界检查（pos <= m_size）
移动现有字符为新内容腾出空间
处理可能的扩容

void MyString::insert(size_t pos, const char* str) { if (pos > m_size) throw out_of_range("Invalid position"); size_t len = strlen(str); if (m_size + len > m_capacity) { reserve(max(m_size + len, m_capacity * 1.5)); } // 移动现有字符 memmove(m_data + pos + len, m_data + pos, m_size - pos + 1); // 插入新内容 memcpy(m_data + pos, str, len); m_size += len; }

3.2 删除操作（erase）

删除操作的实现需要考虑：

要删除的长度可能超过剩余长度
移动字符填补空缺
维护null终止符

void MyString::erase(size_t pos, size_t len) { if (pos >= m_size) return; len = min(len, m_size - pos); memmove(m_data + pos, m_data + pos + len, m_size - pos - len + 1); m_size -= len; }

3.3 查找操作（find）

实现简单的子串查找（KMP算法更高效但较复杂）：

size_t MyString::find(const char* str) const { const char* p = strstr(m_data, str); return p ? p - m_data : npos; }

3.4 修改操作（operator[]）

提供安全的字符访问：

char& MyString::operator[](size_t idx) { if (idx >= m_size) throw out_of_range("Index out of range"); return m_data[idx]; }

4. 性能优化与边界处理

4.1 移动语义优化

现代C++应实现移动构造和移动赋值：

MyString::MyString(MyString&& other) noexcept : m_data(other.m_data), m_size(other.m_size), m_capacity(other.m_capacity) { other.m_data = nullptr; other.m_size = other.m_capacity = 0; } MyString& MyString::operator=(MyString&& rhs) noexcept { if (this != &rhs) { delete[] m_data; m_data = rhs.m_data; m_size = rhs.m_size; m_capacity = rhs.m_capacity; rhs.m_data = nullptr; rhs.m_size = rhs.m_capacity = 0; } return *this; }

4.2 异常安全保证

关键操作应提供强异常安全保证：

void MyString::append(const char* str) { MyString tmp(*this); size_t len = strlen(str); tmp.reserve(m_size + len); strcpy(tmp.m_data + m_size, str); tmp.m_size += len; swap(tmp); }

5. 常见问题与调试技巧

5.1 内存问题排查

内存泄漏：确保每个new都有对应的delete
越界访问：所有操作前检查边界
野指针：移动操作后置空原指针

使用Valgrind或AddressSanitizer检测：

g++ -fsanitize=address -g mystring.cpp

5.2 性能热点分析

频繁扩容：预分配足够空间
不必要的拷贝：使用移动语义
低效查找：小数据用strstr，大数据考虑KMP

5.3 单元测试要点

应覆盖的测试用例：

空字符串操作
边界值测试（刚好需要扩容的大小）
连续多次增删操作
自我赋值检查

TEST(StringTest, AppendStress) { MyString s; for (int i = 0; i < 10000; ++i) { s.append("a"); } ASSERT_EQ(s.length(), 10000); }

6. 进阶优化方向

6.1 小字符串优化（SSO）

对于短字符串（通常<=15字节），直接存储在对象内部避免堆分配：

class MyString { union { char* m_data; char m_sso[16]; }; size_t m_size; bool is_sso() const { return m_size < sizeof(m_sso); } };

6.2 写时复制（Copy-On-Write）

多个字符串共享同一内存，直到需要修改时才复制：

class MyString { struct StringData { char* data; size_t refcount; }; StringData* m_data; };

6.3 多线程安全

通过原子操作保证引用计数的线程安全：

void MyString::add_ref() { __sync_fetch_and_add(&m_data->refcount, 1); }

实现一个完整的string类需要考虑的细节远不止这些，但掌握了核心的增删查改操作后，其他功能如比较运算符、流输出等都可以在此基础上扩展。在实际项目中，建议优先使用std::string，这种模拟实现的主要价值在于学习底层原理和应对技术面试。

C++字符串操作：模拟实现string增删查改