1. 为什么需要模拟实现string类
在C++开发中，标准库提供的string类虽然功能强大，但理解其底层实现原理对于提升编程能力至关重要。通过手动实现一个简化版的string类，我们可以深入理解以下几个关键点：
- 内存管理机制：了解动态内存分配和释放的原理
- 类设计思想：掌握构造函数、析构函数、拷贝控制成员的作用
- 迭代器模式：理解STL容器的迭代器工作原理
- 运算符重载：学习如何自定义类对象的行为
提示：在实际项目中，除非有特殊需求，否则建议直接使用标准库的string类。自定义实现主要用于学习目的。
2. 基础结构设计
2.1 命名空间封装
为了避免与标准库string冲突，我们使用自定义命名空间：
cpp复制namespace st {
class string {
public:
// 接口声明
private:
char* _str; // 字符串指针
size_t _size; // 有效字符数
size_t _capacity; // 容量(不包括'\0')
static const size_t npos = -1; // 特殊值
};
}
关键设计考虑：
_str使用动态分配的字符数组存储字符串_size记录实际字符数(不包括结尾的'\0')_capacity表示当前分配的内存容量npos作为特殊标记值，类似标准库实现
2.2 内存布局示例
假设存储字符串"Hello"：
code复制_str → ['H']['e']['l']['l']['o']['\0']
_size = 5
_capacity = 5 (或更大，取决于实现)
3. 核心成员函数实现
3.1 构造函数与析构函数
全缺省构造函数
cpp复制string(const char* str = "")
: _size(strlen(str))
, _capacity(_size)
{
_str = new char[_capacity + 1]; // 多分配1字节存放'\0'
strcpy(_str, str);
}
注意事项：
- 默认参数为空字符串，确保即使无参构造也能正常工作
- 必须分配_capacity+1的空间以容纳结尾的'\0'
- 使用strcpy保证字符串完整复制
析构函数实现
cpp复制~string() {
delete[] _str; // 释放动态内存
_str = nullptr; // 避免悬垂指针
_size = _capacity = 0;
}
3.2 拷贝控制成员
传统拷贝构造函数
cpp复制string(const string& s)
: _str(nullptr)
, _size(0)
, _capacity(0)
{
char* tmp = new char[s._size + 1];
strcpy(tmp, s._str);
delete[] _str; // 安全处理
_str = tmp;
_size = s._size;
_capacity = s._capacity;
}
现代写法（推荐）
cpp复制string(const string& s)
: _str(nullptr), _size(0), _capacity(0)
{
string tmp(s._str); // 利用构造函数
swap(tmp); // 交换资源
}
void swap(string& other) noexcept {
std::swap(_str, other._str);
std::swap(_size, other._size);
std::swap(_capacity, other._capacity);
}
优势分析：
- 代码更简洁
- 异常安全性更好
- 利用构造函数复用代码
赋值运算符重载
cpp复制// 现代写法（传值方式）
string& operator=(string tmp) {
swap(tmp);
return *this;
}
注意：现代写法通过传值自动调用拷贝构造，利用RAII机制自动管理资源。
4. 迭代器实现
4.1 迭代器类型定义
cpp复制typedef char* iterator;
typedef const char* const_iterator;
4.2 迭代器访问方法
cpp复制iterator begin() { return _str; }
iterator end() { return _str + _size; }
const_iterator begin() const { return _str; }
const_iterator end() const { return _str + _size; }
使用示例：
cpp复制st::string s = "hello";
for(auto it = s.begin(); it != s.end(); ++it) {
cout << *it;
}
5. 容量相关操作
5.1 reserve扩容机制
cpp复制void reserve(size_t new_capacity) {
if(new_capacity > _capacity) {
char* new_str = new char[new_capacity + 1];
strcpy(new_str, _str);
delete[] _str;
_str = new_str;
_capacity = new_capacity;
}
}
关键点：
- 只有当new_capacity大于当前容量时才执行扩容
- 需要多分配1字节存放'\0'
- 先分配新空间，复制数据，再释放旧空间
5.2 resize操作实现
cpp复制void resize(size_t n, char ch = '\0') {
if(n < _size) {
_str[n] = '\0';
_size = n;
} else {
reserve(n);
for(size_t i = _size; i < n; ++i) {
_str[i] = ch;
}
_str[n] = '\0';
_size = n;
}
}
行为说明：
- n < size：截断字符串
- n > size：填充指定字符（默认'\0'）
6. 元素访问与修改
6.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];
}
6.2 push_back实现
cpp复制void push_back(char ch) {
if(_size == _capacity) {
reserve(_capacity == 0 ? 4 : _capacity * 2);
}
_str[_size] = ch;
_size++;
_str[_size] = '\0';
}
扩容策略：
- 初始容量为0时，分配4字节
- 否则按2倍扩容
6.3 append字符串
cpp复制void append(const char* str) {
size_t len = strlen(str);
if(_size + len > _capacity) {
reserve(_size + len);
}
strcpy(_str + _size, str);
_size += len;
}
7. 字符串操作函数
7.1 find查找实现
cpp复制size_t find(char ch, size_t pos = 0) const {
for(size_t i = pos; i < _size; ++i) {
if(_str[i] == ch) {
return i;
}
}
return npos;
}
size_t find(const char* str, size_t pos = 0) const {
const char* p = strstr(_str + pos, str);
return p ? p - _str : npos;
}
7.2 substr子串获取
cpp复制string substr(size_t pos, size_t len = npos) const {
assert(pos < _size);
if(len == npos || pos + len > _size) {
len = _size - pos;
}
string result;
result.reserve(len);
for(size_t i = 0; i < len; ++i) {
result += _str[pos + i];
}
return result;
}
8. 流操作重载
8.1 输出流重载
cpp复制std::ostream& operator<<(std::ostream& os, const string& s) {
os << s.c_str();
return os;
}
8.2 输入流重载（带缓冲优化）
cpp复制std::istream& operator>>(std::istream& is, string& s) {
s.clear();
char ch = is.get();
char buffer[128];
size_t i = 0;
while(!isspace(ch)) {
buffer[i++] = ch;
if(i == sizeof(buffer) - 1) {
buffer[i] = '\0';
s += buffer;
i = 0;
}
ch = is.get();
}
if(i > 0) {
buffer[i] = '\0';
s += buffer;
}
return is;
}
缓冲优化说明：
- 使用局部缓冲区减少频繁扩容
- 当缓冲区满时追加到字符串
- 最后处理缓冲区剩余内容
9. 性能优化与注意事项
9.1 常见性能陷阱
-
频繁扩容：在连续插入操作时，合理预分配空间
cpp复制void reserve_if_needed(size_t additional) { if(_size + additional > _capacity) { reserve(max(_capacity * 2, _size + additional)); } } -
不必要的拷贝：使用移动语义优化临时对象
cpp复制string(string&& other) noexcept : _str(other._str) , _size(other._size) , _capacity(other._capacity) { other._str = nullptr; other._size = other._capacity = 0; }
9.2 异常安全保证
- 基本保证：操作失败时对象仍处于有效状态
- 强保证：关键操作使用拷贝交换惯用法
cpp复制string& operator=(const string& rhs) { string tmp(rhs); // 可能抛出异常 swap(tmp); // 不抛出 return *this; }
9.3 测试建议
-
边界条件测试：
- 空字符串操作
- 在容量边界处操作
- npos特殊值处理
-
内存检查：
- 使用valgrind检测内存泄漏
- 检查所有执行路径的资源释放
-
性能测试：
- 对比标准库实现
- 分析热点函数
实现一个完整的string类需要考虑许多细节问题，这个练习对于理解C++的类设计、内存管理和STL实现原理都非常有帮助。在实际开发中，建议结合单元测试框架如Google Test进行全面的测试验证。