1. 从零开始：string类的核心结构设计
在C++标准库中，string类是最常用的容器之一，但很多初学者对其底层实现原理并不清楚。今天我们就来彻底拆解string类的实现，我会用最直白的方式带你理解每个细节。
首先，我们需要明确string类的三个核心成员变量：
cpp复制class string {
private:
char* _str; // 指向动态分配的字符数组
size_t _size; // 当前存储的有效字符数（不含'\0'）
size_t _capacity; // 当前分配的存储空间总大小
};
这三个成员构成了string类的骨架。_str指向堆上分配的字符数组，_size记录实际存储的字符数量，_capacity记录当前分配的总空间大小。这种设计使得string能够动态增长，同时避免频繁的内存分配。
关键细节：
_size不包括结尾的'\0'，但分配内存时总是需要为'\0'额外预留一个位置。这是很多初学者容易忽略的地方。
2. 构造与析构：字符串的生命周期管理
2.1 构造函数实现要点
无参构造函数创建一个空字符串：
cpp复制string::string()
:_str(new char[1]{'\0'}) // 分配最小空间并初始化为空字符串
,_size(0)
,_capacity(0)
{}
带参构造函数从C风格字符串创建：
cpp复制string::string(const char* str)
:_size(strlen(str)) // 先计算长度
{
_capacity = _size; // 容量初始等于长度
_str = new char[_size + 1]; // 为'\0'额外+1
memcpy(_str, str, _size + 1); // 复制包括'\0'
}
性能优化：避免在初始化列表多次调用strlen。strlen需要遍历整个字符串，性能开销较大。最佳实践是在函数体内只计算一次并复用。
2.2 拷贝构造的深拷贝实现
拷贝构造函数必须实现深拷贝，避免多个对象共享同一块内存：
cpp复制string::string(const string& s)
{
_str = new char[s._capacity + 1]; // 分配新空间
memcpy(_str, s._str, s._size + 1); // 复制数据
_size = s._size;
_capacity = s._capacity;
}
2.3 现代写法的赋值运算符
传统写法需要先释放旧内存再分配新内存。现代写法更简洁安全：
cpp复制string& string::operator=(string s) // 注意这里是传值，会调用拷贝构造
{
swap(s); // 交换当前对象与临时对象的内容
return *this; // 临时对象析构时会释放旧内存
}
void swap(string& s) {
std::swap(_str, s._str);
std::swap(_size, s._size);
std::swap(_capacity, s._capacity);
}
这种写法的优势在于：
- 利用拷贝构造函数完成新内存分配
- 通过交换避免显式内存管理
- 天然处理了自赋值情况
- 异常安全性更高
3. 迭代器设计：指针的优雅封装
3.1 迭代器的本质
string的迭代器本质上是字符指针的typedef：
cpp复制typedef char* iterator;
typedef const char* const_iterator;
对应的begin/end实现：
cpp复制iterator begin() { return _str; }
iterator end() { return _str + _size; }
const_iterator begin() const { return _str; }
const_iterator end() const { return _str + _size; }
注意：标准库的string迭代器可能更复杂，但我们的简化实现已经能完美工作。const迭代器通过返回const指针确保内容不被修改。
3.2 迭代器的典型用法
有了迭代器，我们可以像使用指针一样遍历字符串：
cpp复制string s("hello");
for(auto it = s.begin(); it != s.end(); ++it) {
cout << *it;
}
这种设计使得string与STL算法完美兼容，比如：
cpp复制std::reverse(s.begin(), s.end());
4. 容量相关操作的内存管理
4.1 size与capacity的区别
cpp复制size_t size() const { return _size; } // 实际字符数
size_t capacity() const { return _capacity; } // 分配的总空间
关键理解：
size()返回的是有效字符数（不包括'\0'）capacity()返回的是当前分配的总空间（通常>=size+1）
4.2 clear操作的实现
cpp复制void clear() {
_str[0] = '\0'; // 只需设置结束符
_size = 0; // 重置有效长度
}
重要细节：clear()不会释放内存，只是将字符串置空。这是为了可能的后续重用预留空间，避免频繁内存分配。
4.3 reserve内存预分配
cpp复制void reserve(size_t n) {
if(n > _capacity) {
char* new_str = new char[n + 1]; // +1 for '\0'
memcpy(new_str, _str, _size + 1); // 复制原内容
delete[] _str; // 释放旧内存
_str = new_str;
_capacity = n;
}
}
使用场景：当知道需要存储大量数据时，提前reserve可以避免多次扩容：
cpp复制string s;
s.reserve(1000); // 预先分配足够空间
for(int i=0; i<1000; i++) {
s.push_back('a'); // 不会触发扩容
}
5. 元素访问与修改操作
5.1 安全的元素访问
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];
}
5.2 push_back实现与扩容策略
cpp复制void push_back(char c) {
if(_size == _capacity) {
// 扩容策略：通常2倍增长，但首次从0开始
reserve(_capacity == 0 ? 4 : _capacity * 2);
}
_str[_size] = c;
_size++;
_str[_size] = '\0'; // 别忘了结束符
}
扩容策略分析：
- 初始空字符串：0容量
- 第一次添加：扩容到4
- 后续每次满时：容量翻倍
- 这种策略在时间效率（均摊O(1)）和空间利用率之间取得了平衡
6. 字符串操作的高级实现
6.1 append字符串拼接
cpp复制string& append(const char* str) {
size_t len = strlen(str);
if(_size + len > _capacity) {
reserve(_size + len); // 精确扩容
}
memcpy(_str + _size, str, len + 1); // 包括'\0'
_size += len;
return *this;
}
6.2 insert字符插入
cpp复制string& insert(size_t pos, char c) {
assert(pos <= _size);
if(_size == _capacity) {
reserve(_capacity == 0 ? 4 : _capacity * 2);
}
// 移动pos后的所有字符
memmove(_str + pos + 1, _str + pos, _size - pos + 1);
_str[pos] = c;
_size++;
return *this;
}
注意：memmove比memcpy更安全，因为它能处理内存重叠的情况。在插入操作中，源和目标区域是重叠的。
7. 实战经验与性能优化
7.1 小字符串优化(SSO)
实际的标准库实现通常会使用小字符串优化：
- 对于短字符串(通常<=15字节)，直接存储在对象内部
- 避免堆分配的开销
- 我们的简化实现没有包含这点，但值得了解
7.2 写时复制(COW)的取舍
早期有些实现使用写时复制技术：
- 多个string共享同一内存
- 直到有修改操作时才真正复制
- 现代实现通常不再使用，因为多线程安全问题
7.3 移动语义的支持
C++11后应添加移动构造函数：
cpp复制string(string&& s) noexcept
:_str(s._str), _size(s._size), _capacity(s._capacity)
{
s._str = nullptr; // 确保源对象析构安全
s._size = s._capacity = 0;
}
移动操作可以避免不必要的拷贝，特别是在函数返回值场景：
cpp复制string createString() {
string s("hello");
return s; // 会调用移动构造而非拷贝构造
}
8. 完整测试案例
最后，让我们用一个完整的测试案例验证我们的string实现：
cpp复制void testString() {
// 构造测试
string s1; // 默认构造
string s2("hello"); // 带参构造
// 拷贝测试
string s3 = s2; // 拷贝构造
s1 = s3; // 赋值操作
// 修改测试
s1.push_back('!');
s1.append(" world");
s1.insert(5, ',');
// 迭代器测试
for(auto c : s1) {
cout << c;
}
cout << endl;
// 容量测试
cout << "size: " << s1.size()
<< ", capacity: " << s1.capacity() << endl;
}
这个实现虽然简化，但涵盖了string的核心功能。在实际项目中，你可能还需要考虑：
- 更多的异常安全保证
- 更完善的Unicode支持
- 与其他字符串类型的互操作
- 更丰富的查找和替换功能
通过这个练习，你应该对C++字符串的底层实现有了更深入的理解。记住，理解这些底层细节是成为高级C++开发者的必经之路。