1. 项目概述为什么我们要亲手实现一个String类如果你正在学习C尤其是从C语言转过来那么“string类”绝对是你绕不开的一个坎。在C语言里处理字符串是件挺麻烦的事你得小心翼翼地操作字符数组时刻担心数组越界、内存泄漏。C标准库里的std::string就像个救星它把内存管理、字符串拼接、查找替换这些脏活累活都包了用起来特别顺手。但问题来了面试官总爱问“能说说string类的底层实现吗”或者“手写一个简单的String类试试”这时候如果你只停留在会用的层面心里难免会发虚。这个项目就是带你从零开始模拟实现一个我们自己的MyString类。这绝不是为了造一个比标准库更好的轮子标准库的实现经过千锤百炼我们难以企及。真正的目的是**“通过造轮子来理解汽车”**。你会亲手处理内存的申请与释放理解什么是深拷贝、什么是浅拷贝为什么要有拷贝构造函数和赋值运算符重载以及如何优雅地重载、[]、等运算符。这个过程会让你对C面向对象、资源管理RAII和运算符重载有刻骨铭心的理解这是只看书、只调用API永远无法获得的。无论你是正在啃《C Primer》的小白还是准备面试、需要巩固基础的进阶者这个超详细的解析都能带你走一遍“实现者”的思考路径。我们不追求大而全而是聚焦最核心、最常被问到的部分确保你每一步都知其然更知其所以然。2. 核心设计思路与类框架搭建在动手写代码之前我们必须先想清楚一个基本的字符串类应该长什么样它需要哪些数据成员又该提供哪些最基本的接口2.1 数据成员的设计基石决定上层建筑一个字符串本质上就是一段连续的内存空间用来存放字符并且我们需要知道这段空间有多大以及当前存了多少字符。因此最经典的设计包含三个成员变量class MyString { private: char* _str; // 指向动态分配的字符数组的指针用于存储字符串内容 size_t _size; // 当前字符串的实际长度不包含结尾的\0 size_t _capacity; // 当前分配的内存空间总容量通常_size1 };为什么这么设计char* _str这是核心。我们使用动态内存分配new char[]来管理字符串内容这样字符串的长度就可以在运行时自由变化而不像C风格字符数组那样固定大小。_str指向堆上这片内存的起始位置。size_t _size记录有效字符的个数。比如字符串Hello_size就是5。有这个值我们就能在O(1)时间复杂度内获取字符串长度而不需要像strlen那样遍历。size_t _capacity这是为了效率。如果每次添加字符都重新分配内存效率会极低。_capacity记录了我们总共申请了多少内存。当_size即将达到_capacity时我们才进行一次“扩容”申请一块更大的内存把旧数据拷贝过去然后释放旧内存。这是一种以空间换时间的策略。注意有些简化实现会省略_capacity每次修改都精确分配_size1的内存。这在学习阶段没问题但理解_capacity对于掌握STL容器如vector的扩容机制非常有帮助。2.2 成员函数规划从构造到析构的生命周期一个类最基本的函数是“六大件”默认构造、拷贝构造、移动构造、拷贝赋值、移动赋值、析构。对于管理资源的类我们管理着_str指向的堆内存这六大件至关重要。构造函数们创建对象的不同方式。默认构造函数创建一个空字符串。带参构造函数用一个C风格字符串const char*来初始化。拷贝构造函数用一个已有的MyString对象来初始化一个新对象。这里是深拷贝的关键析构函数对象生命周期结束时负责释放_str申请的堆内存防止内存泄漏。运算符重载让我们的类用起来像内置类型一样自然。赋值运算符str1 str2。同样涉及深拷贝和自赋值问题。下标运算符[]str[0]获取或修改指定位置的字符需提供常量版本和非常量版本。流插入和流提取支持cout myStr和cin myStr。关系运算符,!,,等用于比较字符串。加法运算符字符串拼接通常需要实现str1 str2和str1 “abc”等多种形式。容量操作size()/length()返回_size。capacity()返回_capacity。reserve(size_t n)增加容量为添加字符预留空间。resize(size_t n, char ch)改变_size可能截断或填充字符。修改操作push_back(char c)/append(const char* str)尾部添加。insert(size_t pos, const char* str)在指定位置插入。erase(size_t pos, size_t len)删除部分字符。clear()清空内容_size置0但内存可能不释放。访问与查找c_str()返回底层的C风格字符串指针const char*。find(const char* str, size_t pos 0)查找子串。我们的实现将循序渐进先从最核心、最容易出错的“六大件”和基础运算符开始。3. 从零开始基础成员函数的实现与深拷贝陷阱让我们从最核心的构造函数和析构函数开始。这是理解C资源管理的第一步。3.1 构造函数与析构函数资源的获取与释放默认构造函数应该创建一个合法的空字符串。空字符串并不是_str为nullptr而应该是一个指向只包含结束符\0的堆内存的指针。MyString::MyString() : _str(new char[1]) // 分配1个char的空间 , _size(0) , _capacity(0) { _str[0] \0; // 确保是空字符串 }这里我们分配了1字节存放\0。_capacity设为0表示没有额外空间。这是一种常见设计。带参构造函数接收一个C风格字符串。MyString::MyString(const char* str) : _str(nullptr) , _size(0) , _capacity(0) { if (str nullptr) { // 处理空指针输入 _str new char[1]; _str[0] \0; } else { _size strlen(str); _capacity _size; // 初始容量刚好够用 _str new char[_capacity 1]; // 多分配1位给\0 strcpy(_str, str); // 拷贝内容包括\0 } }这里有几个关键点检查输入指针是否为空这是一种健壮性编程。使用strlen获取长度注意它的时间复杂度是O(n)。分配内存时是_capacity 1为结尾的\0预留空间。使用strcpy进行拷贝它会连带源字符串的\0一起拷贝过去。析构函数的实现简单但至关重要MyString::~MyString() { if (_str) { // 良好的习惯判断指针是否有效 delete[] _str; // 一定要用 delete[] 匹配 new char[] _str nullptr; // 防止野指针 _size _capacity 0; } }记住new[]必须用delete[]来释放。将指针置空是个好习惯。3.2 拷贝构造函数与赋值运算符深拷贝与浅拷贝的生死之战这是String类实现中最经典、最重要的部分也是面试必考点。我们先看一个**错误的“浅拷贝”**例子// 错误示例编译器默认生成的拷贝构造函数浅拷贝 MyString str1(Hello); MyString str2(str1); // 浅拷贝str2._str 和 str1._str 指向同一块内存当str1和str2析构时它们会对同一块内存调用两次delete[]导致未定义行为通常是程序崩溃。这就是“浅拷贝”问题。因此我们必须自己实现深拷贝的拷贝构造函数// 正确的拷贝构造函数深拷贝 MyString::MyString(const MyString other) : _str(nullptr) , _size(other._size) , _capacity(other._capacity) { _str new char[_capacity 1]; strcpy(_str, other._str); // 拷贝内容而非指针 }我们为新对象重新申请了一块内存然后把other的内容拷贝过来。这样两个对象就完全独立了。赋值运算符重载比拷贝构造更复杂一些因为它要处理一个已经存在的对象。它需要完成以下几步防止自赋值str1 str1。释放当前对象持有的旧内存。分配新内存并拷贝数据。返回*this以支持链式赋值a b c。MyString MyString::operator(const MyString other) { // 1. 检查自赋值 if (this other) { return *this; } // 2. 释放旧资源 delete[] _str; // 3. 分配新资源并拷贝 _size other._size; _capacity other._capacity; _str new char[_capacity 1]; strcpy(_str, other._str); // 4. 返回当前对象的引用 return *this; }一个经典的优化技巧拷贝并交换Copy-and-Swap上面的写法有缺陷如果new分配内存失败抛出异常当前对象的_str已经被delete对象状态被破坏。更健壮的写法是利用“拷贝并交换” idiomMyString MyString::operator(const MyString other) { if (this ! other) { MyString temp(other); // 调用拷贝构造创建临时副本 swap(temp); // 交换当前对象和临时对象的内容 } // 临时对象temp离开作用域析构掉旧的资源 return *this; }这需要你先实现一个高效的swap成员函数。这种写法异常安全且代码简洁。4. 让类更好用关键运算符与常用接口实现实现了生命周期管理我们的MyString类已经有了骨架。现在给它加上血肉让它用起来更方便。4.1 下标访问与C风格字符串转换下标运算符[]需要提供两个版本一个允许修改一个用于常量对象。// 非常量版本返回字符的引用可以修改 char MyString::operator[](size_t pos) { // 一定要进行边界检查 assert(pos _size); // 使用assert或在release版本中用if抛出异常 return _str[pos]; } // 常量版本用于const对象返回字符的值 const char MyString::operator[](size_t pos) const { assert(pos _size); return _str[pos]; }c_str()接口非常简单但必不可少因为很多旧的C库函数只认const char*。const char* MyString::c_str() const { return _str; // 直接返回内部指针但必须是const防止外部修改 }4.2 流运算符重载实现输入输出重载和能让我们的类与标准输入输出流无缝协作。它们通常被声明为友元函数。// 在类内声明 friend class MyString { friend std::ostream operator(std::ostream os, const MyString str); friend std::istream operator(std::istream is, MyString str); }; // 在类外定义 std::ostream operator(std::ostream os, const MyString str) { os str._str; // 直接输出内部的C风格字符串 return os; // 返回流对象以支持链式调用 } // 在类外定义 (简化版不考虑空格等问题) std::istream operator(std::istream is, MyString str) { // 简单起见假设输入一个不带空格的单词 char buffer[1024]; // 临时缓冲区 is buffer; str MyString(buffer); // 利用赋值运算符 return is; }的完整实现需要考虑缓冲区大小、内存动态增长等问题这里是一个简化版。4.3 关系运算符与字符串拼接关系运算符如的实现可以依赖于标准库的strcmp。bool operator(const MyString lhs, const MyString rhs) { return strcmp(lhs.c_str(), rhs.c_str()) 0; } bool operator(const MyString lhs, const MyString rhs) { return strcmp(lhs.c_str(), rhs.c_str()) 0; } // 其他 !, , , 可以利用 和 实现加法运算符用于字符串拼接。注意它不应该修改任何一个操作数而是返回一个新的MyString对象。MyString operator(const MyString lhs, const MyString rhs) { MyString result; // 创建新对象 result.reserve(lhs._size rhs._size); // 预留足够空间 // 这里需要实现append功能将lhs和rhs的内容追加到result // 简化写法 // result lhs; // result.append(rhs.c_str()); return result; // 返回新对象可能涉及返回值优化RVO }更常见的做法是实现运算符然后让基于来实现这样更高效。5. 动态内存管理的核心reserve、resize与append一个实用的字符串类必须能高效地处理字符串的增长。这就涉及到容量管理。5.1 reserve预分配内存的智慧reserve函数用于增加字符串的容量_capacity以避免后续添加字符时频繁重新分配内存。它不应该改变字符串的内容_size和内容本身。void MyString::reserve(size_t new_capacity) { if (new_capacity _capacity) { return; // 如果请求的容量不大于当前容量什么都不做 } // 1. 申请新的、更大的内存块 char* new_str new char[new_capacity 1]; // 1 for \0 // 2. 拷贝旧数据到新内存包括结尾的\0 strcpy(new_str, _str); // 3. 释放旧内存 delete[] _str; // 4. 更新指针和容量 _str new_str; _capacity new_capacity; // _size 保持不变 }这里的关键是new_capacity 1我们总是为结尾的\0多分配一个字符。reserve是push_back、append、等操作高效的基础。5.2 resize改变字符串的大小resize用于直接改变字符串的长度_size。如果新的长度大于当前长度可以用指定字符填充如果小于当前长度则截断字符串。void MyString::resize(size_t new_size, char ch \0) { if (new_size _size) { // 需要增大 if (new_size _capacity) { // 如果新大小超过容量需要扩容。通常不是精确扩容而是按策略如2倍扩容 reserve(new_size); // 简单起见这里精确扩容。实际std::string有增长因子。 } // 用字符ch填充新增的部分 for (size_t i _size; i new_size; i) { _str[i] ch; } _str[new_size] \0; // 设置新的结束符 _size new_size; } else if (new_size _size) { // 需要减小直接截断 _str[new_size] \0; _size new_size; } // 如果 new_size _size 什么都不做 }5.3 push_back 与 append构建字符串有了reserve实现push_back就很简单了。void MyString::push_back(char ch) { if (_size _capacity) { // 空间已满需要扩容 // 常见的扩容策略如果容量为0扩到某个初始值如15否则扩到原来的2倍。 size_t new_capacity (_capacity 0) ? 15 : _capacity * 2; reserve(new_capacity); } _str[_size] ch; _size; _str[_size] \0; // 别忘了更新结束符 }append函数用于追加一个C风格字符串或另一个MyString对象其内部逻辑与push_back类似但需要计算追加字符串的长度并可能触发一次扩容。MyString MyString::append(const char* str) { if (str nullptr) return *this; size_t len strlen(str); if (_size len _capacity) { // 需要扩容至少扩到 _size len reserve(_size len); } strcpy(_str _size, str); // 从原字符串的结尾处开始拷贝 _size len; // strcpy 已经拷贝了\0所以这里不需要再设置 return *this; // 支持链式调用 }有了append运算符的实现就水到渠成了MyString MyString::operator(const char* str) { return append(str); } MyString MyString::operator(const MyString str) { return append(str.c_str()); }6. 避坑指南与高级话题从实现中领悟C精髓在亲手实现的过程中你会遇到各种陷阱。理解并绕过它们你的C水平会提升一个档次。6.1 必须处理的边界情况与异常安全空指针处理在所有接受const char*参数的函数如构造函数、append中都要考虑输入可能是nullptr。直接对nullptr调用strlen或strcpy会导致程序崩溃。下标越界operator[]必须进行边界检查。在Debug版本可以使用assert在Release版本可以考虑抛出std::out_of_range异常。自赋值问题在拷贝赋值运算符operator中必须首先检查if (this other)。如果不检查在释放自身内存后再去拷贝“对方”的数据而“对方”就是自己此时数据已经被释放导致拷贝无效数据或访问已释放内存。异常安全在赋值运算符或可能修改对象状态的操作中要考虑异常。前面提到的“拷贝并交换” idiom是保证强异常安全性的经典方法。基本思想是任何可能失败的操作如new都在修改当前对象状态之前完成。6.2 移动语义现代C的性能利器C11及以上我们之前实现的拷贝构造函数和赋值运算符都是“深拷贝”在涉及临时对象或返回值时会产生不必要的拷贝开销。C11引入了移动语义来解决这个问题。移动构造函数“窃取”临时对象右值的资源而不是拷贝。// 移动构造函数 MyString::MyString(MyString other) noexcept // noexcept 声明不抛异常对移动操作很重要 : _str(other._str) , _size(other._size) , _capacity(other._capacity) { // 将源对象置于有效但可析构的状态 other._str nullptr; other._size 0; other._capacity 0; }它直接接管了other._str指针然后将other的指针置空。这样当临时对象other被析构时delete[] nullptr是安全的。移动赋值运算符同理MyString MyString::operator(MyString other) noexcept { if (this ! other) { delete[] _str; // 释放自己的旧资源 // 窃取资源 _str other._str; _size other._size; _capacity other._capacity; // 置空源对象 other._str nullptr; other._size 0; other._capacity 0; } return *this; }实现了移动语义后像MyString str3 str1 str2;这样的语句str1 str2产生的临时对象会直接移动给str3避免了一次深拷贝效率大幅提升。6.3 迭代器简介与STL算法接轨一个完整的容器通常需要提供迭代器。对于MyString迭代器就是字符指针的简单封装。class MyString { public: using iterator char*; using const_iterator const char*; iterator begin() { return _str; } iterator end() { return _str _size; } // 指向\0符合STL“尾后迭代器”约定 const_iterator begin() const { return _str; } const_iterator end() const { return _str _size; } const_iterator cbegin() const { return _str; } const_iterator cend() const { return _str _size; } };有了迭代器你就可以在MyString上使用基于范围的for循环甚至可以使用algorithm中的许多算法如std::find,std::sort对字符串排序字符等。MyString str(Hello); for (char ch : str) { // 基于范围的for循环 ch toupper(ch); } // 现在 str 的内容是 HELLO6.4 SSO短字符串优化浅析你可能会发现我们的实现无论字符串多短比如Hi都需要在堆上分配内存。而new和delete是比较耗时的操作。标准库的std::string在许多实现中如GCC的libstdc和Clang的libc采用了一种叫**短字符串优化SSO**的技术。其基本思想是在对象内部预留一个固定大小的缓冲区例如16字节。当字符串长度很短比如小于16时直接将字符串内容存储在这个内部的缓冲区中而不去堆上分配内存。只有当字符串超过这个阈值时才采用我们上面实现的动态分配策略。这种优化极大地提升了短字符串操作的性能。实现SSO会使得类的拷贝控制逻辑构造、拷贝、赋值、移动变得更加复杂因为需要根据字符串长度在两种存储模式间切换。作为初学者理解其概念即可这是std::string高效的重要原因之一。7. 完整代码示例与测试将上述所有部分组合起来我们就得到了一个相对完整的MyString类。下面是一个高度精简但包含核心功能的版本并附上测试用例。#include iostream #include cstring #include cassert class MyString { private: char* _str; size_t _size; size_t _capacity; void _reserve(size_t new_cap) { if (new_cap _capacity) return; char* new_str new char[new_cap 1]; strcpy(new_str, _str); delete[] _str; _str new_str; _capacity new_cap; } public: // 构造函数 MyString(const char* str ) { _size strlen(str); _capacity _size; _str new char[_capacity 1]; strcpy(_str, str); } // 拷贝构造函数深拷贝 MyString(const MyString other) : _size(other._size), _capacity(other._capacity) { _str new char[_capacity 1]; strcpy(_str, other._str); } // 拷贝赋值运算符简易版 MyString operator(const MyString other) { if (this ! other) { delete[] _str; _size other._size; _capacity other._capacity; _str new char[_capacity 1]; strcpy(_str, other._str); } return *this; } // 析构函数 ~MyString() { delete[] _str; _str nullptr; _size _capacity 0; } // 容量操作 size_t size() const { return _size; } size_t capacity() const { return _capacity; } void reserve(size_t new_cap) { _reserve(new_cap); } // 访问 const char* c_str() const { return _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]; } // 修改 void push_back(char ch) { if (_size _capacity) { reserve(_capacity 0 ? 15 : _capacity * 2); } _str[_size] ch; _size; _str[_size] \0; } MyString append(const char* str) { size_t len strlen(str); if (_size len _capacity) { reserve(_size len); } strcpy(_str _size, str); _size len; return *this; } MyString operator(const char* str) { return append(str); } // 友元函数 friend std::ostream operator(std::ostream os, const MyString str); }; std::ostream operator(std::ostream os, const MyString str) { os str._str; return os; } // 测试代码 int main() { // 测试构造 MyString str1; std::cout str1 (default): \ str1 \, size str1.size() std::endl; MyString str2(Hello); std::cout str2: \ str2 \, size str2.size() std::endl; // 测试拷贝构造 MyString str3 str2; // 拷贝构造 std::cout str3 (copy of str2): \ str3 \ std::endl; // 测试赋值 MyString str4; str4 str2; // 拷贝赋值 std::cout str4 (assigned from str2): \ str4 \ std::endl; // 测试修改 str2[0] h; std::cout str2 after str2[0]h: \ str2 \ std::endl; std::cout str3 (deep copy, should not change): \ str3 \ std::endl; // 测试追加和扩容 MyString str5(Hi); std::cout str5 capacity before append: str5.capacity() std::endl; str5.append(, World! This is a long string.); std::cout str5 after append: \ str5 \, size str5.size() , capacity str5.capacity() std::endl; // 测试运算符 MyString str6(C ); str6 is ; str6 powerful!; std::cout str6: \ str6 \ std::endl; return 0; }运行这个测试你可以清晰地看到深拷贝如何工作以及reserve和append如何协作管理内存。通过这个从零搭建的过程字符串类不再是一个黑盒它的每一次构造、赋值、扩容都变得清晰可见。这才是学习C核心机制最有效的方式。当你再面对std::string时你看到的将不再是一个简单的工具而是一个精心设计、蕴含了资源管理、效率优化等诸多智慧的对象。