1. C++ string类的底层实现解析
作为C++程序员，string类是我们日常开发中最常用的工具之一。但你是否真正理解它的底层实现机制？今天我将带大家从零开始，手把手实现一个简化版的string类，深入剖析其核心设计思路和关键技术细节。
string本质上是一个动态字符数组的封装，它需要解决三个核心问题：内存管理、操作效率和接口易用性。我们先来看最基础的成员变量设计：
cpp复制private:
char* _str; // 指向动态分配的字符数组
int _size; // 当前字符串长度（不含'\0'）
int _capacity; // 当前分配的内存容量
static const unsigned int npos = -1; // 特殊值，表示不存在的位置
这种设计与STL中的vector类似，采用_size和_capacity分离的策略，既保证了内存使用的效率，又避免了频繁的内存分配。
2. 核心成员函数实现
2.1 构造函数与析构函数
构造函数需要考虑多种初始化场景，我们提供了两种实现方式：
cpp复制// 方式一：分开实现
string() : _str(new char[1]), _size(0), _capacity(0) {
_str[0] = '\0'; // 保证空字符串也以'\0'结尾
}
string(const char* str) :
_str(new char[strlen(str) + 1]),
_size(strlen(str)),
_capacity(strlen(str)) {
strcpy(_str, str);
}
// 方式二：全缺省参数
string(const char* str = "") : _size(strlen(str)) {
_capacity = _size;
_str = new char[_size + 1];
strcpy(_str, str);
}
关键细节：无论哪种实现，都必须确保字符串以'\0'结尾，这是C风格字符串的基本要求。
析构函数需要特别注意内存释放的正确方式：
cpp复制~string() {
delete[] _str; // 必须使用delete[]匹配new[]
_str = nullptr; // 避免悬垂指针
_size = _capacity = 0;
}
2.2 拷贝控制：深拷贝与浅拷贝
string类必须实现深拷贝，否则多个对象会共享同一块内存。我们提供传统和现代两种写法：
cpp复制// 传统写法
string(const string& s) {
_str = new char[s._capacity + 1];
strcpy(_str, s._str);
_size = s._size;
_capacity = s._capacity;
}
// 现代写法（利用临时对象+swap）
string(const string& s) {
string tmp(s._str); // 通过构造函数创建临时对象
swap(tmp); // 交换资源所有权
}
赋值运算符也需要特别注意自赋值问题：
cpp复制// 传统写法
string& operator=(const string& s) {
if(this != &s) { // 防止自赋值
char* tmp = new char[s._capacity + 1];
strcpy(tmp, s._str);
delete[] _str;
_str = tmp;
_size = s._size;
_capacity = s._capacity;
}
return *this;
}
// 现代写法（参数直接传值利用拷贝构造）
string& operator=(string s) {
swap(s); // 与临时对象交换资源
return *this;
}
3. 字符串操作实现
3.1 内存管理：reserve与resize
reserve用于预分配内存，避免频繁扩容：
cpp复制void reserve(int n) {
if(n > _capacity) {
char* tmp = new char[n + 1]; // +1给'\0'
strcpy(tmp, _str);
delete[] _str;
_str = tmp;
_capacity = n;
}
}
resize则用于调整字符串长度：
cpp复制void resize(int n, char ch = '\0') {
if(n > _size) {
reserve(n);
for(int i = _size; i < n; i++)
_str[i] = ch;
_size = n;
_str[_size] = '\0';
} else {
_str[n] = '\0';
_size = n;
}
}
3.2 元素访问：下标与迭代器
重载[]运算符提供类似数组的访问方式：
cpp复制char& operator[](int pos) {
assert(pos < _size);
return _str[pos];
}
const char& operator[](int pos) const {
assert(pos < _size);
return _str[pos];
}
迭代器实现（简单指针封装）：
cpp复制typedef char* iterator;
iterator begin() { return _str; }
iterator end() { return _str + _size; }
3.3 字符串修改操作
push_back和append是基础操作：
cpp复制void push_back(char ch) {
if(_size == _capacity)
reserve(_capacity == 0 ? 4 : 2 * _capacity);
_str[_size] = ch;
_str[++_size] = '\0';
}
void append(const char* str) {
int len = strlen(str);
if(_size + len > _capacity)
reserve(_size + len);
strcpy(_str + _size, str);
_size += len;
}
insert和erase需要处理元素移动：
cpp复制void insert(size_t pos, char ch) {
assert(pos <= _size);
if(_size == _capacity)
reserve(_capacity == 0 ? 4 : 2 * _capacity);
for(int i = _size; i >= (int)pos; i--)
_str[i+1] = _str[i];
_str[pos] = ch;
_size++;
}
void erase(size_t pos, int len = npos) {
assert(pos < _size);
if(len == npos || len > _size - pos) {
_str[pos] = '\0';
_size = pos;
} else {
strcpy(_str + pos, _str + pos + len);
_size -= len;
}
}
4. 实用功能实现
4.1 查找与子串
find实现简单字符串查找：
cpp复制size_t find(char ch, size_t pos = 0) const {
assert(pos < _size);
for(int i = pos; i < _size; i++)
if(_str[i] == ch) return i;
return npos;
}
size_t find(const char* str, size_t pos = 0) const {
assert(pos < _size);
char* p = strstr(_str + pos, str);
return p ? p - _str : npos;
}
substr提取子字符串：
cpp复制string substr(size_t pos = 0, size_t len = npos) {
string sub;
for(int i = pos; i < _size && i < pos + len; i++)
sub += _str[i];
return sub;
}
4.2 流操作符重载
输入输出流操作符重载：
cpp复制ostream& operator<<(ostream& out, const string& s) {
for(auto ch : s) out << ch;
return out;
}
istream& operator>>(istream& in, string& s) {
s.clear();
char 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;
}
5. 性能优化与注意事项
5.1 扩容策略优化
默认的2倍扩容策略在多数情况下表现良好，但在特定场景下可能需要调整：
- 超大字符串处理：可以考虑固定步长扩容（如每次1MB）
- 精确预知长度时：直接reserve目标大小
5.2 常见陷阱
- 内存泄漏：确保每个new都有对应的delete
- 缓冲区溢出：所有操作前检查边界
- 自赋值问题：赋值运算符要处理a=a的情况
- 异常安全：现代写法通常更安全
5.3 与现代C++的结合
C++11后可以引入移动语义：
cpp复制string(string&& s) noexcept : _str(s._str), _size(s._size), _capacity(s._capacity) {
s._str = nullptr;
s._size = s._capacity = 0;
}
string& operator=(string&& s) noexcept {
if(this != &s) {
delete[] _str;
_str = s._str;
_size = s._size;
_capacity = s._capacity;
s._str = nullptr;
s._size = s._capacity = 0;
}
return *this;
}
6. 完整实现与测试
将上述所有代码整合到一个头文件中，并添加必要的测试用例：
cpp复制// 测试代码示例
void test_string() {
string s1;
string s2 = "hello";
string s3 = s2;
s1 = s2;
s1 += " world";
s1.insert(5, ", C++");
cout << s1 << endl; // 输出: hello, C++ world
cout << s1.substr(7, 3) << endl; // 输出: C++
string s4;
cin >> s4; // 测试���入
cout << "You entered: " << s4 << endl;
}
实现一个完整的string类需要考虑诸多细节，但理解其核心原理后，我们不仅能更好地使用标准库中的string，还能根据特定需求进行定制扩展。在实际项目中，除非有特殊需求，否则建议直接使用std::string，它经过了充分优化和测试。