STL string 类源码实现详解

现代推荐写法采用 Copy-and-Swap 惯用法，利用临时对象完成深拷贝后再交换，能自动处理资源清理且代码更简洁：

void swap(string& tmp) {
    std::swap(_str, tmp._str);
    std::swap(_size, tmp._size);
    std::swap(_capacity, tmp._capacity);
}

string(const string& s) {
    string tmp(s); // 调用拷贝构造创建临时对象
    swap(tmp);     // 交换资源
}

注意：若未对成员变量赋初值（如 nullptr），在交换前确保临时对象已正确初始化，否则可能导致悬空指针。

赋值运算符重载

同样面临深浅拷贝问题，且需防范自我赋值。 传统方式需先检查 this == &other，再释放旧内存并申请新内存。 Copy-and-Swap 版本通过按值传递参数，隐式触发拷贝构造生成临时副本，随后交换即可，无需手动 delete。

string& operator=(string tmp) {
    swap(tmp);
    return *this;
}

这种写法不仅安全，还天然支持链式赋值。

迭代器与访问

迭代器本质是指针。begin() 返回首字符地址，end() 返回最后一个字符后的位置（即 \0 处）。 下标运算符 operator[] 提供读写与只读两个版本，需断言下标有效性。

iterator begin() { return _str; }
const_iterator end() const { return _str + _size; }
char& operator[](size_t i) { assert(i < _size); return _str[i]; }

容量与大小管理

size() 和 capacity() 分别返回当前长度与容量。 reserve(n) 负责扩容，当请求容量大于当前容量时，重新分配更大内存并拷贝旧数据。一般只扩不缩，避免频繁分配开销。 empty() 判断是否为空，可通过比较 _size 是否为零实现，比调用 strcmp 更高效。

void reserve(size_t n) {
    if (n > _capacity) {
        char* tmp = new char[n + 1];
        strcpy(tmp, _str);
        delete[] _str;
        _str = tmp;
        _capacity = n;
    }
}
bool empty() const { return _size == 0; }

字符串修改操作

尾插与追加

push_back(char c) 在末尾添加字符。若空间不足，采用二倍扩容策略。插入后记得补上 \0。 append(const char* s) 追加字符串，逻辑类似，需注意目标缓冲区剩余空间。 operator+= 可复用上述函数简化实现。

void push_back(char c) {
    if (_size == _capacity) {
        reserve(_capacity == 0 ? 4 : _capacity * 2);
    }
    _str[_size++] = c;
    _str[_size] = '\0';
}

插入与删除

insert(pos, ...) 涉及中间位置的数据移动。 插入字符时，从尾部开始逐个向后挪动，腾出位置。注意 size_t 无符号特性，循环条件应设为 end > pos 而非 end >= pos，防止头部插入时 end 减至 0 后发生下溢变成极大正数导致死循环。 插入字符串同理，先移动尾部 \0 及后续字符，再填入新内容。 erase(pos, len) 删除指定范围字符，将后续字符向前覆盖。若删除至末尾，只需截断。

void insert(size_t pos, char c) {
    assert(pos <= _size);
    if (_size == _capacity) {
        reserve(_capacity == 0 ? 4 : _capacity * 2);
    }
    size_t end = _size + 1;
    while (end > pos) {
        _str[end] = _str[end - 1];
        --end;
    }
    _str[pos] = c;
    _size++;
}

substr 截取子串，新建 string 对象并填充数据。 clear 仅将首字符置为 \0 并重置长度，不释放内存，效率更高。

string substr(size_t pos, size_t len) {
    assert(pos < _size);
    if (len >= _size - pos) len = _size - pos;
    string tmp;
    tmp.reserve(len);
    for (size_t i = 0; i < len; ++i) {
        tmp += _str[pos + i];
    }
    return tmp;
}

查找与比较

find 支持查找字符或子串。字符查找线性扫描即可；子串查找可利用 strstr 辅助，返回相对偏移量。 关系运算符重载中，只需实现 < 和 ==，其余可通过组合推导得出，减少冗余代码。

bool operator<(const string& s1, const string& s2) {
    return strcmp(s1.c_str(), s2.c_str()) < 0;
}
bool operator==(const string& s1, const string& s2) {
    return strcmp(s1.c_str(), s2.c_str()) == 0;
}

输入输出流

重载 >> 和 << 使 string 能配合标准流使用。 输入时跳过前导空白，读取非空白字符直到遇到分隔符。为避免频繁扩容，可使用局部缓冲数组暂存。 输出时遍历字符逐个写入流。

istream& operator>>(istream& in, string& s) {
    s.clear();
    const int N = 256;
    char buff[N] = { 0 };
    int i = 0;
    char ch = in.get();
    while (ch == ' ' || ch == '\n' || ch == '\t') ch = in.get();
    while (ch != ' ' && ch != '\n' && ch != '\t') {
        buff[i++] = ch;
        if (i == N - 1) { buff[i] = '\0'; s += buff; i = 0; }
        ch = in.get();
    }
    if (i > 0) { buff[i] = '\0'; s += buff; }
    return in;
}
ostream& operator<<(ostream& out, const string& s) {
    for (auto ch : s) out << ch;
    return out;
}

这样实现了一个功能完备的 string 类，涵盖了内存管理、资源获取即初始化（RAII）思想以及常用算法逻辑。