1. MyString类设计思路解析
在C++标准库中，string类是一个功能强大的字符串处理工具，但它的实现细节往往被隐藏。通过仿写MyString类，我们可以深入理解字符串类的底层实现原理。这个MyString类的设计有几个关键特点：
- 引用计数机制：采用共享内存的方式减少拷贝开销
- 柔性数组技术：使用结构体末尾的柔性数组存储字符串内容
- 写时复制(COW)：只有在修改时才创建新副本
- 移动语义支持：通过右值引用优化性能
1.1 核心数据结构设计
MyString类的核心是一个包含引用计数的结构体：
cpp复制struct StrNode {
int ref; // 引用计数
int len; // 字符串长度
int capa; // 容量
char data[]; // 柔性数组
};
这种设计有以下几个优势：
- 内存紧凑：引用计数和字符串数据存储在连续内存中
- 访问高效：通过指针直接访问，减少间接寻址
- 柔性扩展：data数组大小可根据需要动态调整
注意：柔性数组必须是结构体的最后一个成员，这是C/C++的标准要求。这种技术也称为"结构体尾部数组"或"零长度数组"。
1.2 内存管理策略
MyString采用32字节为最小分配单位，这是基于以下考虑：
cpp复制static const size_t STRLEN = 32;
static StrNode* getNode(size_t len) {
len = (len > STRLEN) ? len : STRLEN;
size_t total = sizeof(StrNode) + sizeof(char) * len;
StrNode* newnode = (StrNode*)malloc(sizeof(char) * total);
// ...
}
这种设计实现了：
- 小字符串优化：短字符串直接内联存储，避免频繁堆分配
- 内存对齐：32字节边界对齐提高访问效率
- 减少碎片：固定大小块便于内存池管理
2. 关键实现细节剖析
2.1 引用计数机制实现
引用计数是MyString的核心特性，它通过浅拷贝实现字符串共享：
cpp复制MyString(const MyString& st) : pstr(st.pstr) {
if(pstr != nullptr) {
pstr->ref += 1; // 增加引用计数
}
}
这种实现需要注意：
- 线程安全：标准实现需要原子操作保证线程安全
- 循环引用：需要额外机制处理可能的循环引用
- 写时复制：修改时需要检查引用计数
2.2 写时复制(COW)实现
当需要修改共享字符串时，MyString会创建新副本：
cpp复制void append(const size_t count, char x) {
if(pstr->ref > 1) { // 被多个对象引用
pstr->ref--; // 减少原引用计数
StrNode* p = getNode(pstr->len + count + 1);
strcpy(p->data, pstr->data);
pstr = p; // 指向新副本
}
// 执行修改操作...
}
COW的优势在于：
- 减少不必要的拷贝：只读操作不触发复制
- 延迟分配：直到真正需要修改时才分配新内存
- 内存共享：相同内容的字符串共享存储
2.3 移动语义支持
现代C++的移动语义可以避免不必要的拷贝：
cpp复制MyString(MyString&& st) : pstr(st.pstr) {
st.pstr = nullptr; // 源对象放弃所有权
}
MyString& operator=(MyString&& st) {
if(this != &st) {
destroy(); // 释放当前资源
pstr = st.pstr; // 接管资源
st.pstr = nullptr;
}
return *this;
}
移动操作的关键点：
- 资源转移：直接转移指针所有权
- 源对象置空：确保源对象析构安全
- 自赋值检查：防止自我移动导致问题
3. 完整实现与关键方法
3.1 构造与析构函数实现
构造函数需要考虑空字符串和普通字符串两种情况：
cpp复制MyString(const char* sp = nullptr) : pstr(nullptr) {
if(sp != nullptr && *sp != '\0') {
int len = strlen(sp);
pstr = getNode(len + 1); // 额外1字节存放'\0'
pstr->ref = 1;
pstr->len = len;
strcpy(pstr->data, sp);
}
}
~MyString() {
destroy();
}
void destroy() {
if(pstr != nullptr && --pstr->ref == 0) {
FreeNode(pstr); // 引用计数归零才释放
}
pstr = nullptr;
}
3.2 赋值运算符重载
拷贝赋值采用"拷贝并交换"惯用法：
cpp复制MyString& operator=(const MyString& st) {
if(this != &st) {
MyString(st).swap(*this); // 创建临时对象并交换
}
return *this;
}
void swap(MyString& s) {
std::swap(pstr, s.pstr); // 仅交换指针
}
这种实现的好处是：
- 异常安全：操作不会影响原对象状态
- 代码复用：利用拷贝构造函数实现
- 自赋值安全：自然处理自我赋值情况
3.3 字符串操作函数
append函数展示了完整的COW实现：
cpp复制MyString& append(const size_t count, char x) {
if(pstr == nullptr) { // 空字符串情况
pstr = getNode(count + 1);
memset(pstr->data, x, count);
pstr->len = count;
pstr->ref = 1;
pstr->data[pstr->len] = '\0';
}
else if(pstr->ref == 1) { // 唯一引用
if(pstr->capa - pstr->len < count) { // 需要扩容
InSize(*this, pstr->capa + count);
}
}
else { // 共享字符串
pstr->ref--;
StrNode* p = getNode(pstr->len + count + 1);
strcpy(p->data, pstr->data);
p->ref = 1;
p->len = pstr->len;
pstr = p;
}
memset(pstr->data + pstr->len, x, count);
pstr->len += count;
pstr->data[pstr->len] = '\0';
return *this;
}
4. 性能优化与注意事项
4.1 内存管理优化
- 预分配策略：初始分配32字节减少小字符串分配开销
- 扩容算法：按需扩容避免频繁重新分配
- 内存池：可考虑实现定制分配器进一步优化
4.2 线程安全考虑
当前实现不是线程安全的，生产环境需要考虑：
- 原子引用计数：使用std::atomic保证引用计数安全
- 锁机制：关键操作加锁保护
- 不可变设计：将字符串设计为不可变对象
4.3 常见问题与解决方案
问题1：内存泄漏
- 确保所有路径都正确维护引用计数
- 使用RAII技术管理资源
问题2：悬垂指针
- 移动操作后必须置空源对象指针
- 避免返回内部指针的裸指针
问题3：性能瓶颈
- 频繁COW可能降低性能
- 考虑实现小字符串优化(SSO)
4.4 扩展功能建议
- 迭代器支持：实现begin()/end()以支持范围for
- 运算符重载：实现+、+=等字符串连接操作
- 查找替换：添加find/replace等常用字符串操作
- 格式化支持：实现类似sprintf的格式化功能
5. 实现对比与选择
5.1 与标准库string对比
| 特性 | MyString实现 | std::string实现 |
|---|---|---|
| 内存管理 | 引用计数+COW | 通常为深拷贝 |
| 小字符串优化 | 32字节预分配 | 实现依赖(通常有) |
| 线程安全 | 不安全 | 通常安全 |
| 移动语义 | 支持 | C++11后支持 |
5.2 不同场景下的选择建议
- 只读场景：引用计数实现更高效
- 高频修改：深拷贝可能更合适
- 多线程环境：需要线程安全实现
- 内存敏感：考虑SSO优化版本
在实际项目中，应根据具体需求选择合适的字符串实现。标准库string通常是首选，但在特定场景下，定制化的字符串类可能提供更好的性能。