前言
string是 C++ 中最常用的字符串工具，但多数人只懂用、不懂其底层逻辑。
这篇会带你手搓一个简易string ：从内存管理的构造 / 析构，到深拷贝的拷贝构造 / 赋值重载，再到基础接口封装，帮你吃透string的核心机制，同时掌握 C++ 类设计的关键思路。
📚 C++ 初阶
【 C++发展史、命名空间、输入输出、缺省参数、函数重载 】
【 C++引用、内联函数、auto、范围 for、nullptr 】
目录
[四、字符串的 "查找与子串操作" 类接口](#四、字符串的 “查找与子串操作” 类接口)
[七、<< 和 >> 重载接口](#七、<< 和 >> 重载接口)
一、前置工作
在实现string前，为了避免和库中冲突，所以我们需要定义一个命名空间：
cpp
namespace ljh
{
class string
{
};
}我们要实现的简易 string 的底层实际是动态顺序表，所以，需要定义一个字符指针 去指向字符串，同时还得搭配记录当前字符串长度 和存储空间容量的变量，这样后续才能通过动态调整字符指针指向的堆内存空间，实现字符串的增删改等操作。
cpp
namespace ljh
{
class string
{
private:
size_t _size;
size_t _capacity;
char* _str;
};
}同时我们在上一篇的学习中发现，标准库的 string 类里还定义了一个 npos 静态共有成员变量，它主要用于作为某些接口的缺省参数，以及在查找类操作中表示'未找到'的结果标识。
cpp
namespace ljh
{
class string
{
private:
size_t _size;
size_t _capacity;
char* _str;
public:
static size_t npos;
};
size_t string::npos = -1;//库中的定义就是无符号整数的-1也就是无符号整数的最大值
}以上就是我们在实现各类接口之前，搭建好的整体框架了
二、默认成员函数
1、构造函数
cpp
// 全缺省构造函数：支持无参调用（默认空字符串），或传入C风格字符串
string(const char* str = "")
{
_size = strlen(str); // 计算字符串长度（不包含末尾的\0）
_capacity = _size; // 容量初始化为当前字符串长度
_str = new char[_capacity + 1];// 分配空间：额外多1个字节存\0
// 【注意】strcpy的特性：会自动拷贝到源字符串的\0为止（包括\0本身）
// 但如果源字符串中间包含\0，strcpy会提前终止，导致拷贝不完整
// 当然对于标准 C 风格常量字符串（仅末尾含 \0）的场景，strcpy 能正常完成拷贝
// 但是出于代码的统一性，所以我整个string拷贝相关的代码都用的是memcpy
// strcpy(_str, str);
// 改用memcpy：按指定字节数（有效字符数 + 1个\0）拷贝，避免上述问题
memcpy(_str, str, _size + 1);
}2、析构函数
cpp
//析构函数
~string()
{
delete[] _str;
_str = nullptr;
_size = _capacity = 0 ;
}3、拷贝构造函数
【传统写法】
cpp
string(const string& s)
{
_str = new char[s._capacity + 1];
memcpy(_str, s._str, s._size + 1);
_size = s._size;
_capacity = s._capacity;
}由于string类包含动态申请的资源（比如_str指向的堆内存），因此不能使用浅拷贝（浅拷贝仅复制指针地址，会导致多个对象共用同一块内存，引发析构时重复释放等问题），必须实现深拷贝：
先为新构造的对象单独开辟一块与原对象容量匹配的内存空间，再将原对象的字符串数据完整拷贝到新空间中。
需要注意：这里不能使用strcpy函数 ------ 因为strcpy是按 "遇到'\0'就停止" 的规则拷贝，若原字符串中存在'\0'（比如类似"hello\0!!!!!!!!!!"这种包含内嵌'\0'的情况），strcpy会只拷贝到第一个'\0'为止，无法完整复制所有数据。因此代码中用memcpy（按指定字节数拷贝），确保连'\0'在内的所有数据都被完整复制。
【现代写法】
cpp
void swap(string& s)
{
std::swap(_str, s._str);
std::swap(_size, s._size);
std::swap(_capacity, s._capacity);
}
//拷贝构造（现代写法）
string(const string& s)
:_str(nullptr)
, _size(0)
, _capacity(0)
{
string tmp(s._str);
swap(tmp);
}由于要用到 swap 接口，所以我先在前面提前写好这个成员函数（其实用算法库的 std::swap 也可以，但咱们 string 类里已经实现了这个接口，就直接用成员函数版本）。
假设我们要用对象 s 拷贝构造一个新对象 s1（方便后面描述），现代写法的思路是：先构造一个和 s 内容完全一致的临时对象 tmp，接着让 s1 和 tmp 交换资源。但要注意：不能直接交换两个 string 对象 ------ 如果直接交换对象，会触发一次拷贝构造和两次赋值运算符重载（这俩操作都是深拷贝，开销很大）；而只交换对象的成员变量（_str、_size、_capacity），本质是 3 次内置类型（指针、整数）的交换，几乎没有额外开销。
整体逻辑就是 "让 tmp 干脏活"：深拷贝的工作全交给 tmp 做，要是这过程中出了问题（比如内存分配失败），也只会影响 tmp，不会波及目标对象 s1；等 tmp 把深拷贝的资源准备好，s1 直接通过交换 "坐享其成" 拿到资源；最后函数结束，tmp 出了作用域会自动销毁，顺带把交换过来的 "空资源"（s1 初始化时的默认值）清理掉，不会有任何残留。
切记：在交换之前，一定要先对目标对象（比如这里的 s1）的成员变量做初始化（比如把_str 设为 nullptr、_size 和_capacity 设为 0）。否则如果直接拿未初始化的成员去交换，会导致野指针、随机值等未定义行为，后续 tmp 销毁时还可能误释放非法资源。
但是，现代写法在含\0的字符串场景有缺陷 ：依赖 C 风格字符串构造的临时对象会以\0截断内容，无法完整拷贝\0后的字符，而传统写法按_size遍历复制可避免此问题。
4、赋值运算符重载
【传统写法】
cpp
string& operator=(string& s)
{
//如果两个不相等
if (*this != s)
{
char* tmp = new char[s._capacity + 1];
memcpy(tmp,s._str,_size+1);
delete[]_str;
_str = tmp;
_size = s._size;
_capacity = s._capacity;
}
return *this;
}传统写法的逻辑是：先为新数据开辟独立内存，把 s 的内容完整拷贝过去；接着释放当前对象原来的内存，让当前对象的指针指向新内存；最后同步更新长度和容量 ------ 这样既完成了深拷贝，也避免了浅拷贝的资源共享问题。
【现代写法】
先讲错误写法：构造出 tmp 对象后直接交换两个 string 对象，这种写法完全错误 ------ 因为赋值运算符里调用std::swap时，std::swap内部会调用赋值运算符，由此陷入 "赋值→swap→赋值" 的死循环。
而之前拷贝构造的现代写法，虽然可以直接交换对象（只是效率低），但它的前提是临时对象已经通过拷贝构造完成了深拷贝，和这里的错误写法场景不同。
cpp
string& operator=(string tmp)
{
if(*this != tmp)
{
swap(tmp);
return *this;
}
}最终的现代写法（让 tmp 先通过拷贝构造完成深拷贝，再调用成员函数 swap 交换）是正确的 ------ 成员 swap 仅交换内置类型的成员变量，不会触发赋值 / 拷贝，既避免了死循环，也保证了异常安全。
三、字符串操作接口
1、reserve
cpp
//用于预分配内存、扩容容器容量、缩容是非约束行为、不会对创建好的空间进行初始化
void reserve(size_t n)
{
// 仅当请求容量超过当前容量时执行扩容操作
if (n > _capacity)
{
// 分配新的字符数组，额外+1用于存储字符串终止符'\0'
// 注意：_capacity仅记录可存储的有效字符数，不包含终止符
char* tmp = new char[n + 1];
// 将原字符串内容（包括可能存在的中间'\0'）复制到新空间
// _size+1会将\0也拷贝过去
memcpy(tmp, _str,_size+1);
// 释放原空间，防止内存泄漏
delete[] _str;
// 更新字符串指针指向新空间
_str = tmp;
// 更新容量为新分配的大小（不包含终止符的空间）
_capacity = n;
}
}这里不用 strcpy 拷贝的原因是：strcpy 遇到 '\0' 就会停止拷贝，但如果字符串中间本身就包含 '\0'，用 strcpy 会导致拷贝不完整。而 memcpy 是直接按指定的字符个数来拷贝，能避免这个问题，所以我在所有需要拷贝的地方，都用 memcpy 这个函数。
2、push_back
cpp
void push_back(char ch)
{
if (_size == _capacity)
{
// 2倍扩容
reserve(_capacity == 0 ? 4 : _capacity * 2);
}
_str[_size] = ch;
++_size;
//补'\0'
_str[_size] = '\0';
}3、append
cpp
void append(const char* str)
{
assert(str);
size_t len = strlen(str);
//如果len+_size = _capacity就代表刚好够
//大于代表空间不够了
if (len + _size > _capacity)
{
//至少扩容到len+_size
reserve(len+_size);
}
//由于拷贝len+1个字符，所以\0也被拷贝过去了
memcpy(_str + _size, str,len+1);
_size += len;
}4、insert
该接口我仅实现两种函数重载：一种是在指定位置 pos 插入 n 个字符，另一种是在 pos 位置插入字符串。
在指定位置 pos 插入 n 个字符：
cpp
//在指定位置插入n个字符
void insert(size_t pos, size_t n,char ch)
{
//pos等于_size等于尾插
assert(pos<=_size);
//扩容逻辑
if (_size + n > _capacity)
{
//这块不能随便二倍扩容，因为你也不知道_size + n是大于2倍_size还是小于
reserve(_size+n);
}
//挪动数据方法一：
//int end = _size;
//while (end >= (int)pos)
//{
// _str[end + n] = _str[end];
// end--;
//}
//挪动数据方法二：
//size_t end = _size;
//while (end != npos && end >= pos )
//{
// _str[end + n] = _str[end];
// end--;
//}
//挪动数据方法三：
size_t end = _size+1;
while (end > pos)
{
_str[end + n - 1] = _str[end - 1];
end--;
}
//填充字符
for (size_t i = 0; i < n; i++)
{
_str[pos + i] = ch;
}
_size += n;
//不用给_size位置加\0，因为挪动数据时\0也被挪到_size位置了
}这个接口最核心的问题出在挪动数据的实现部分，我先给你写一种错误的挪动方式做示例：
cpp
size_t end = _size;
while (end >= pos)
{
_str[end + n] = _str[end];
end--;
}这段挪动代码看着没问题，但在pos=0的场景下会出严重问题：
当最后一次挪动完成后，
end会减到 - 1------ 但end是无符号整数类型，-1 在无符号数里会直接溢出成该类型的最大值（比如 64 位系统下是18446744073709551615）。这时候循环条件end >= pos（即 "最大值>= 0"）会一直成立，代码会陷入死循环，还会访问非法内存导致崩溃。
现在来分析我给出的 3 种相对正确的实现方式：
挪动数据方法一：
cpp
int end = _size;
while (end >= (int)pos)
{
_str[end + n] = _str[end];
end--;
}这种写法看似解决了pos=0时的问题，但也引入了新隐患：当_size超过有符号整数的最大值时，把_size转换成int类型会发生数值截断，导致后续逻辑出错。
举个例子：假设_size为有符号整数最大值+1：
cpp
我用32位二进制演示 size_t _size=2147483648 转 int 的截断过程：
步骤1：size_t类型的2147483648的二进制（32位无符号数）
2147483648对应的32位二进制是：
1000 0000 0000 0000 0000 0000 0000 0000
步骤2：强制转成int（32位有符号数）
32位有符号数用补码表示：
1. 最高位是1 → 表示负数；
2. 补码转原码：
① 先取反（除符号位）：1111 1111 1111 1111 1111 1111 1111 1111
② 再加1：1000 0000 0000 0000 0000 0000 0000 0000
3. 对应的十进制值就是：-2147483648也就是说end直接变成负数了，根本就不会进入循环更别提挪动数据了
挪动数据方法二：
cpp
size_t end = _size;
// end != npos：拦截end减到-1（无符号溢出值）的情况，避免死循环
// end >= pos：只挪动pos及之后的字符（含末尾'\0'）
while (end != npos && end >= pos )
{
_str[end + n] = _str[end];
end--;
}这种写法仅通过增加end != npos的判断，直接规避了end为 - 1（无符号数溢出后的值）时再次进入循环的问题，功能上能精准终止循环，逻辑简单直接；仅需注意注释说明该判断是为了拦截end溢出为 - 1 的情况，避免后续维护时误删即可
挪动数据方法三：
cpp
//挪动数据方法三：
size_t end = _size + 1;
while (end > pos)
{
_str[end + n - 1] = _str[end - 1];
end--;
}这种写法通过将end初始化为_size + 1（包含字符串终止符\0的下一位），结合end > pos的显式边界判断，直接规避了无符号数溢出的问题：
无需依赖溢出特性，仅通过索引范围控制循环终止，逻辑直观且无隐性规则依赖，是更稳健的挪动实现方式
在 pos 位置插入字符串：
cpp
//在指定位置插入字符串
void insert(size_t pos,const char* str)
{
//pos必须是有效数据
//pos=_size是尾插
assert(pos <= _size);
size_t len = strlen(str);
//扩容
if (len + _size > _capacity)
{
reserve(len+_size);
}
//挪动数据
size_t end = _size;
while (end >= pos && end != npos)
{
_str[end + len] = _str[end];
end--;
}
//插入数据
for (size_t i = 0; i < len; i++)
{
_str[pos + i] = str[i];
}
_size += len;
}这个接口的挪动数据逻辑，和前面的实现是一样的，我就不再重复说明了，你选自己习惯的方式写就行
5、erase
cpp
void erase(size_t pos, size_t len = npos)
{
//起始删除位置必须在有效字符范围内，防止越界访问
//同时避免了_size为0的问题，当_size=0时，pos始终小于_size
assert(pos < _size);
// 场景1：删除从pos到字符串末尾的所有字符（len为默认值 或 待删除长度覆盖剩余全部字符）
if (len == npos || pos + len >= _size)
{
// 直接在pos位置写入字符串结束符，截断后续字符
_str[pos] = '\0';
// 更新有效字符长度，完成逻辑删除（无需释放内存，仅修改长度标记）
_size = pos;
}
// 场景2：删除指定长度的字符（len合法且未覆盖到字符串末尾）
else
{
// 计算待删除区间的结束下一个位置（即需要保留的第一个字符位置）
size_t end = pos + len;
// 内存覆盖：将end开始的字符依次向前拷贝到pos位置，直至覆盖到原结束符
// 循环终止条件包含_size，保证字符串结束符'\0'也被正确迁移
while (end <= _size)
{
_str[pos++] = _str[end++];
}
// 更新有效字符长度：减去实际删除的字符数
_size -= len;
}
}6、resize
cpp
//开空间、填值、删值（容量不会变化）
void resize(size_t n, char ch = '\0')
{
//删值
if (n < _size)
{
_size = n;
_str[_size] = '\0';
}
//填值
else
{
//如果n大于_capacity才会扩容
reserve(n);
//从已有的有效数据后开始填
for (size_t i = _size; i < n; i++)
{
_str[i] = ch;
}
_size = n;
_str[_size] = '\0';
}
}7、clear
cpp
void clear()
{
_str[0] = '\0';
_size = 0;
}8、size
cpp
size_t size() const
{
return _size;
}9、capacity
cpp
size_t capacity() const
{
return _capacity;
}10、empty
cpp
bool empty() const
{
return _size == 0;
}11、swap
cpp
void swap(string& s)
{
std::swap(_str, s._str);
std::swap(_size, s._size);
std::swap(_capacity, s._capacity);
}12、operator+=
cpp
string& operator+=(char ch)
{
push_back(ch);
return *this;
}
string& operator+=(const char* ch)
{
append(ch);
return *this;
}哎呀这接口我之前给落啦！本来该早早安排上的～不过咱直接薅push_back和append的羊毛就行，主打一个 "拿来就用，爽到飞起"！
四、字符串的 "查找与子串操作" 类接口
1、find
cpp
//从字符串pos位置开始往后找字符c
size_t find(char ch,size_t pos = 0)
{
assert(pos < _size);
for (size_t i = pos; i < _size; i++)
{
if (_str[i] == ch)
{
return i;
}
}
return npos;
}
//从字符串pos位置开始往后找字符串str
size_t find(const char* str, size_t pos = 0)
{
assert(pos < _size);
const char* ptr = strstr(_str + pos, str);
if (ptr)
{
return ptr - _str;
}
else
{
return npos;
}
}第一个接口直接暴力查找，找到就返回对应字符的下标，没找到返回npos
第二个接口调用了C语言str系列函数，如果找到了返回对应位置的指针，没找到返回空指针，找到后想要获取字符串第一个位置的下标：
2、substr
cpp
//获取子串 从pos开始取len个字符，如果len = npos,或者pos+len大于字符串长度，取pos后面的所有字符
string substr(size_t pos = 0, size_t len = npos)
{
assert(pos < _size);
size_t n = len;
//如果len = npos或者pos+len大于字符串长度，更新应获取的字符串长度
if (len == npos || pos+len >_size)
{
n = _size - pos;
}
string tmp;
//开空间
tmp.reserve(n);
//拷贝数据 - 结束条件必须是n+pos，因为i不一定是从0开始的
for (size_t i = pos; i < n+pos; i++)
{
//不用考虑'\0'，因为+=已经将'\0'补了
tmp += _str[i];
}
return tmp;
}五、字符串访问类接口
1、迭代器
cpp
class string
{
public:
typedef char* iterator;
typedef const char* const_iterator;
iterator begin()
{
return _str;
}
iterator end()
{
return _str + _size;
}
const_iterator begin() const
{
return _str;
}
const_iterator end() const
{
return _str + _size;
}
}哈哈哈哈，悄悄说：string的迭代器其实就是 "换了个马甲的指针"（当然不是所有迭代器都这德性哈）！谁让string底层是字符数组呢，直接拿指针当迭代器遍历，主打一个 "简单粗暴又好用"~
重点敲黑板 ：迭代器类型必须设成public！不然藏得严严实实的，外面想用都摸不着门～
反向迭代器咱先放一放哈 ------ 这玩意儿得 "包装" 一下才好用，等学到 List 的时候，咱就能把它的原理扒得明明白白啦～
小tips：范围for
另外你们记不记得最开始学的范围 for？那就是个 "语法糖刺客"！底层偷偷把自己换成迭代器遍历了～所以不用对这些花里胡哨的语法感到神秘，本质都是老熟人～
2、operator[]
cpp
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[]就是 "双胞胎开关"：
没加const的版本是 "读写自由人"------ 既能看字符，也能直接改；
加了const的版本直接 "锁死编辑权"------ 只能瞅一眼，想改？门儿都没有～
3、c_str
cpp
const char* c_str() const
{
return _str;
}六、运算符重载接口
1、<
【写法一】
cpp
//写法1：
bool operator<(const string& s) const
{
size_t i1 = 0;
size_t i2 = 0;
while (i1 < _size && i2 < s._size)
{
if (_str[i1] < s._str[i2])
{
return true;
}
else if (_str[i1] > s._str[i2])
{
return false;
}
else
{
++i1;
++i2;
}
}
//走到这还有这3种情况要处理
"hello" "hello" false
"helloxx" "hello" false
"hello" "helloxx" true
//处理写法1：
/*if (i1 == _size && i2 != s._size)
{
return true;
}
else
{
return false;
}*/
//写法2：
//return i1 == _size && i2 != s._size;
//写法3：
//return _size < s._size;
}【写法二】
cpp
bool operator<(const string& s) const
{
int ret = memcmp(_str, s._str, _size < s._size ? _size : s._size);
// "hello" "hello" false
// "helloxx" "hello" false
// "hello" "helloxx" true
//如果ret==0考虑上面3种情况，否则直接返回结果
return ret == 0 ? _size < s._size : ret < 0;
}注意 ：以上两种比较方式，均优先对较短长度的部分进行逐字符比对；若短部分的字符完全一致，则通过 "本串长度是否更短" 来决定最终结果。
2、==
cpp
bool operator==(const string& s) const
{
return _size == s._size && memcmp(_str, s._str, _size) == 0;
}两个字符串要相等，需同时满足两个条件：
- 长度相等 ：如果长度不一样，字符串必然不相等，直接返回
false； - 内容完全一致 ：长度相等时，再通过
memcmp逐字符比较所有内容，确保每一位都相同。
3、<=
cpp
bool operator<=(const string& s) const
{
return *this < s || *this == s;
}4、>
cpp
bool operator>(const string& s) const
{
return !(*this <= s);
}5、>=
cpp
bool operator>=(const string& s) const
{
return !(*this < s);
}6、!=
cpp
bool operator!=(const string& s) const
{
return !(*this == s);
}实际只需要实现前两个核心逻辑即可，后面的功能可以直接复用已实现的部分，不用重复编写代码。
七、<< 和 >> 重载接口
1、流插入运算符重载
cpp
ostream& operator<<(ostream& out,const string& s)
{
/*for (size_t i = 0; i < s.size(); i++)
{
out << s[i];
}*/
for (auto e: s)
{
out << e;
}
return out;
}流插入运算符（<<）不适合重载为类的成员函数 ------ 因为成员函数的左操作数会被*this占用，会导致使用顺序（比如cout << s）与预期颠倒。
因此，直接将其重载为全局函数更合理；又因为这里不需要访问类的私有成员，所以也不用声明为友元函数。
2、流提取运算符重载
cpp
istream& operator>>(istream& in, string& s)
{
s.clear();
char ch = in.get();
// 处理前缓冲区前面的空格或者换行
while (ch == ' ' || ch == '\n')
{
ch = in.get();
}
char buff[128];
int i = 0;
while (ch != ' ' && ch != '\n')
{
buff[i++] = ch;
if (i == 127)
{
buff[i] = '\0';
s += buff;
i = 0;
}
ch = in.get();
}
if (i != 0)
{
buff[i] = '\0';
s += buff;
}
return in;
}上面展示的是完整代码，但接下来我会先从一些不完整的代码入手，逐步补充、完善到最终的完整版本。
注意：cout和cin这类对象默认是禁止拷贝的，所以在使用时只能传递它们的引用（具体原因我会在讲解 IO 流相关内容时详细说明）。
这是流提取的错误实现 ------ 当输入到空格或换行时，程序会陷入阻塞状态。
因为cin的>>运算符默认不会读取空格和换行符，这些字符会被当作输入的 "结束标识" 留在输入缓冲区中；后续的in >> ch会一直等待有效字符，从而导致进程阻塞。
这次修改的核心是用get()来读取输入 ------get()是标准输入对象的成员函数，它会读取输入中的所有字符 （包括换行符\n和空格），避免了之前>>运算符跳过空白字符的问题。
这个版本存在两个主要缺陷：
未清空旧数据，连续读取会拼接混乱 ：若连续执行多次
cin >> s，新读取的内容会直接拼接到字符串s的旧数据后面（比如第一次读"abc"，第二次读"def"，结果会是"abcdef"），不符合流提取 "覆盖旧值" 的预期行为。逐字符拼接导致频繁扩容 ：每次用
s += ch拼接单个字符，当输入字符串较长时，字符串会频繁触发内存扩容（重新分配更大空间、拷贝旧数据），造成不必要的性能损耗。缓冲区开头是空格或者 '\n'，遇到空格或者 '\n'就直接结束了
添加 s.clear() 是为了解决「连续提取两次字符串时，第一次的旧数据没有被覆盖」的问题 ------ 比如连续执行 cin >> s1 >> s2，若不先清空 s，第二次读取的内容会拼接在第一次的结果后面，导致数据错误。
当前实现的缺陷：
- 每次通过
s += ch拼接字符时，若输入的字符串过长，字符串会频繁触发 "扩容（重新分配内存、拷贝旧数据）" 操作，导致性能损耗较大。- 缓冲区开头是空格或者 '\n'，遇到空格或者 '\n'就直接结束了
最终版本解决的两个核心问题：
- 解决开头遇空白直接结束的问题：通过循环读取并跳过输入开头的空格 / 换行（只读取不插入字符串），确保后续能正常读取有效字符；
- 减少字符串频繁扩容的性能损耗：用固定大小的缓冲区批量暂存字符，满额后再拼接至字符串，大幅降低内存扩容的次数。
