C++ string类底层实现与增删查改操作详解

1. 为什么需要模拟实现string的增删查改？

在C++开发中，string是最基础也最常用的数据类型之一。标准库提供的string类虽然功能完善，但作为开发者，理解其底层实现原理对提升编程能力至关重要。通过手动实现string的增删查改操作，可以深入理解以下几个关键点：

首先，内存管理机制。string本质上是一个动态字符数组，需要处理内存分配、扩容和释放等问题。比如当字符串长度超过当前容量时，如何高效地重新分配内存？这与vector的实现有异曲同工之妙。

其次，边界条件处理。比如在insert操作时，位置参数超出字符串长度该怎么处理？erase时起始位置大于结束位置又该如何？这些细节决定了代码的健壮性。

最后，性能优化考量。比如reserve和resize的区别，小字符串优化(SSO)技术，以及移动语义的应用等。这些都是面试中经常被问到的核心知识点。

2. 基础结构设计与构造函数实现

2.1 类成员变量设计

一个基础的string类需要包含三个核心成员变量：

cpp复制class MyString {
private:
    char* _data;      // 存储字符串数据的指针
    size_t _size;     // 当前字符串长度（不含'\0'）
    size_t _capacity; // 当前分配的存储容量
};

这里有一个关键设计决策：是否要实现小字符串优化(SSO)。对于短字符串（通常16字节以内），可以直接存储在栈上避免堆分配。但为了简化实现，我们先采用最基本的动态分配方案。

2.2 构造函数与析构函数

构造函数需要处理多种初始化情况：

cpp复制// 默认构造函数
MyString() : _data(new char[1]), _size(0), _capacity(0) {
    _data[0] = '\0';
}

// 从C风格字符串构造
MyString(const char* str) {
    _size = strlen(str);
    _capacity = _size;
    _data = new char[_capacity + 1];
    strcpy(_data, str);
}

// 拷贝构造函数（深拷贝）
MyString(const MyString& other) {
    _size = other._size;
    _capacity = other._capacity;
    _data = new char[_capacity + 1];
    strcpy(_data, other._data);
}

// 析构函数
~MyString() {
    delete[] _data;
    _data = nullptr;
    _size = _capacity = 0;
}

注意：所有构造函数都必须保证字符串以'\0'结尾，这是C++字符串的基本约定。

3. 核心操作：增删查改实现

3.1 增加操作（append/insert）

append是最常用的增加操作，其核心是检查容量并可能触发扩容：

cpp复制void append(const char* str) {
    size_t len = strlen(str);
    if (_size + len > _capacity) {
        reserve(_size + len); // 扩容
    }
    strcpy(_data + _size, str);
    _size += len;
}

insert操作更复杂，需要移动现有字符：

cpp复制void insert(size_t pos, const char* str) {
    if (pos > _size) {
        throw std::out_of_range("Insert position out of range");
    }
    
    size_t len = strlen(str);
    if (_size + len > _capacity) {
        reserve(_size + len);
    }
    
    // 移动原有字符
    memmove(_data + pos + len, _data + pos, _size - pos + 1);
    // 插入新内容
    memcpy(_data + pos, str, len);
    _size += len;
}

3.2 删除操作（erase/clear）

erase需要处理多种边界情况：

cpp复制void erase(size_t pos = 0, size_t len = npos) {
    if (pos >= _size) return;
    
    len = std::min(len, _size - pos);
    memmove(_data + pos, _data + pos + len, _size - pos - len + 1);
    _size -= len;
}

clear操作相对简单：

cpp复制void clear() {
    _data[0] = '\0';
    _size = 0;
}

3.3 查找操作（find）

实现基本的子串查找：

cpp复制size_t find(const char* str, size_t pos = 0) const {
    if (pos >= _size) return npos;
    
    const char* result = strstr(_data + pos, str);
    return result ? result - _data : npos;
}

3.4 修改操作（replace）

replace需要处理长度变化的特殊情况：

cpp复制void replace(size_t pos, size_t len, const char* str) {
    if (pos > _size) {
        throw std::out_of_range("Replace position out of range");
    }
    
    len = std::min(len, _size - pos);
    size_t str_len = strlen(str);
    
    if (str_len > len) {
        size_t diff = str_len - len;
        if (_size + diff > _capacity) {
            reserve(_size + diff);
        }
        memmove(_data + pos + str_len, _data + pos + len, _size - pos - len + 1);
    } else if (str_len < len) {
        memmove(_data + pos + str_len, _data + pos + len, _size - pos - len + 1);
    }
    
    memcpy(_data + pos, str, str_len);
    _size += str_len - len;
}

4. 内存管理与性能优化

4.1 动态扩容策略

string的核心性能瓶颈在于内存分配，合理的扩容策略至关重要：

cpp复制void reserve(size_t new_capacity) {
    if (new_capacity <= _capacity) return;
    
    // 常见策略：按几何增长（如2倍）而非线性增长
    size_t actual_capacity = std::max(_capacity * 2, new_capacity);
    char* new_data = new char[actual_capacity + 1];
    
    strcpy(new_data, _data);
    delete[] _data;
    _data = new_data;
    _capacity = actual_capacity;
}

4.2 移动语义支持

现代C++中，移动语义可以大幅提升性能：

cpp复制// 移动构造函数
MyString(MyString&& other) noexcept 
    : _data(other._data), _size(other._size), _capacity(other._capacity) {
    other._data = nullptr;
    other._size = other._capacity = 0;
}

// 移动赋值运算符
MyString& operator=(MyString&& other) noexcept {
    if (this != &other) {
        delete[] _data;
        _data = other._data;
        _size = other._size;
        _capacity = other._capacity;
        other._data = nullptr;
        other._size = other._capacity = 0;
    }
    return *this;
}

5. 完整实现与测试案例

5.1 运算符重载

使类更易用：

cpp复制// 下标运算符
char& operator[](size_t pos) {
    if (pos >= _size) throw std::out_of_range("Index out of range");
    return _data[pos];
}

const char& operator[](size_t pos) const {
    if (pos >= _size) throw std::out_of_range("Index out of range");
    return _data[pos];
}

// 流输出运算符
friend std::ostream& operator<<(std::ostream& os, const MyString& str) {
    os << str._data;
    return os;
}

5.2 测试用例

验证各功能正确性：

cpp复制void test_my_string() {
    // 构造测试
    MyString s1;
    MyString s2("hello");
    MyString s3 = s2;
    
    // 增删测试
    s2.append(" world");
    s2.insert(5, " beautiful");
    s2.erase(5, 10);
    
    // 查找替换测试
    size_t pos = s2.find("world");
    if (pos != MyString::npos) {
        s2.replace(pos, 5, "C++");
    }
    
    // 移动语义测试
    MyString s4 = std::move(s2);
}

6. 常见问题与性能调优

6.1 内存泄漏排查

实现string类最容易出现的问题就是内存泄漏。有几个关键检查点：

1. 所有new操作是否有对应的delete
2. 拷贝构造函数和赋值运算符是否实现为深拷贝
3. 移动操作后是否将源对象置为有效状态

可以使用工具如Valgrind或AddressSanitizer来检测内存问题。

6.2 性能优化技巧

1. 预分配策略：对于知道最终大小的字符串，提前reserve可以避免多次分配
2. SSO优化：对短字符串（如16字节内）使用栈存储
3. 写时复制：多个string共享同一内存，直到需要修改时才复制（需考虑线程安全）
4. 内存池：频繁创建销毁小字符串时，使用内存池减少系统调用

6.3 线程安全考虑

标准string通常不是线程安全的，如果需要在多线程环境下使用，可以考虑：

1. 对共享字符串加锁
2. 使用不可变字符串模式
3. 每个线程维护自己的字符串副本

实现一个完整的string类需要考虑的细节非常多，但通过这个过程可以深入理解C++的内存管理、性能优化和异常安全等核心概念。这也是为什么string的实现经常出现在中高级C++面试题中。