C++ STL：从零手写 string 及高频易错点复盘

3. 拷贝构造

关键点：C++ 语法禁止拷贝构造传值传参，否则会导致无限递归调用栈溢出。参数必须使用引用（const string&）。

string(const string& ch) { 
    _str = new char[ch._capacity + 1]; 
    strcpy(_str, ch._str); 
    _size = ch._size; 
    _capacity = ch._capacity; 
}

4. 析构函数

记得释放资源并将指针置空，防止悬垂指针。

~string() { 
    delete[] _str; 
    _str = NULL; 
    _size = _capacity = 0; 
}

三、功能接口详解

1. reserve

该接口仅修改 _capacity，不改变 _size。常用于提前分配内存以避免后续频繁扩容。

• 只负责扩容，若传入参数小于当前容量通常不做操作。
• 预留空间包含末尾 \0 的位置。

void reserve(int n) { 
    if (n > _capacity) { 
        char* temp = new char[n+1]; 
        strcpy(temp, _str); 
        delete[] _str; 
        _str = temp; 
        _capacity = n; 
    } 
}

注意：不要在构造函数中调用 reserve。此时成员变量尚未初始化，直接访问可能导致非法访问或逻辑错误。

2. c_str

返回指向内部 C 风格字符串的常量指针，用于兼容 C 语言接口。

• 返回 const char*，不可通过该指针修改内容。
• 指针依赖对象生命周期，对象修改或销毁后指针失效。

const char* c_str() const { return _str; }

3. PushBack

在末尾追加单个字符。若空间不足需先扩容。

void PushBack(const char ch) { 
    if (_size == _capacity) { 
        reserve(_capacity == 0 ? 4 : 2 * _capacity); 
    } 
    _str[_size++] = ch; 
    _str[_size] = 0; 
}

扩容时需判断 _capacity 是否为 0，避免一直按 0 扩容。

4. Append

在末尾追加字符串。逻辑与 PushBack 类似，但需处理批量追加时的扩容策略。

void Append(const char* str) { 
    int len = strlen(str); 
    if (_size + len > _capacity) { 
        reserve(_size + len > 2*_capacity ? _size + len : 2 * _capacity); 
    } 
    strcpy(_str+_size, str); 
    _size += len; 
}

这里采用了更智能的扩容策略：如果追加长度过大，直接按需求扩容；否则按 2 倍扩容，平衡性能与内存占用。

5. Insert

支持在指定位置插入字符或字符串。插入会导致后续字符后移，时间复杂度为 O(n)。

// 插入字符
void Insert(int pos, const char ch) { 
    assert(pos <= _size && pos >= 0); 
    if (_size == _capacity) { 
        reserve(_capacity == 0 ? 4 : 2 * _capacity); 
    } 
    int cur = _size; 
    while (cur >= pos) { 
        _str[cur + 1] = _str[cur]; 
        cur--; 
    } 
    _str[pos] = ch; 
    _size++; 
}

// 插入字符串
void Insert(int pos, const char* str) { 
    assert(pos <= _size && pos >= 0); 
    int len = strlen(str); 
    if (_size + len > _capacity) { 
        reserve(_size + len > 2*_capacity ? _size + len : 2 * _capacity); 
    } 
    int cur = _size; 
    while (cur >= pos) { 
        _str[cur + len] = _str[cur]; 
        cur--; 
    } 
    strncpy(_str+pos, str, len); 
    _size += len; 
}

注意插入字符串时使用 strncpy 而非 strcpy，避免将 \0 也拷贝进去覆盖原有数据。

6. erase

删除指定位置或范围的字符。这里演示从指定位置删除指定长度的版本。

void erase(size_t pos, size_t len) { 
    assert(pos >= 0 && pos < _size); 
    if (len >= _size - pos) { 
        _str[pos] = 0; 
        _size -= (_size - pos); 
    } else { 
        while (pos + len <= _size) { 
            _str[pos] = _str[pos + len]; 
            pos++; 
        } 
        _size -= len; 
    } 
}

7. substr

截取子串。这是一个容易踩坑的地方。

返回值是 string 对象，调用拷贝构造。如果未显式定义深拷贝，编译器生成的浅拷贝会导致两个对象共享同一块内存，析构时重复释放引发崩溃。

string substr(size_t pos, size_t len) const { 
    assert(pos >= 0 && pos < _size); 
    if (len > _size - pos) { 
        len = _size - pos; 
    } 
    string temp; 
    for (int i = pos; i < pos + len; i++) { 
        temp += _str[i]; 
    } 
    return temp; 
}

务必确保拷贝构造函数实现了深拷贝，即重新开辟空间并复制数据。

8. Find

查找字符或子串首次出现的位置。失败返回 npos。

size_t find(char ch, size_t pos = 0) { 
    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) { 
    assert(pos < _size); 
    char* ret = strstr(_str + pos, str); 
    if (ret != nullptr) return ret - _str; 
    return npos; 
}

使用 strstr 时需注意其返回的是指针，需转换为下标。

四、运算符重载

1. 赋值运算符 (=)

推荐采用拷贝并交换（Copy-and-Swap） 惯用法，既简洁又异常安全。

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

string& operator=(string str) { 
    Swap(str); 
    return *this; 
}

相比传统写法手动管理内存，这种方式利用临时对象的析构自动回收旧资源，且天然支持自赋值。

2. 比较运算符 (<, ==, etc.)

基础比较复用 strcmp，其余运算符基于基础运算组合实现。

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; 
}
// 其他运算符可基于 < 和 == 推导

注意：这些非成员函数声明不能放在类内，因为参数列表隐含了 this 指针。

3. 流运算符 (<<, >>)

输出较简单，逐个字符写入即可。输入则需处理缓冲区满的情况。

std::ostream& operator<<(std::ostream& out, const string& s) { 
    for (auto ch : s) { out << ch; } 
    return out; 
}

std::istream& operator>>(std::istream& in, string& s) { 
    s.clear(); 
    const int N = 256; 
    char buff[N]; 
    int i = 0; 
    char ch; 
    ch = in.get(); 
    while (ch != ' ' && ch != '\n') { 
        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; 
}

输入流实现中使用了固定缓冲区避免频繁分配，遇到空格或换行停止读取。

五、完整代码实现

头文件 (string.h)

#define _CRT_SECURE_NO_WARNINGS
#pragma once
#include <string.h>
#include <assert.h>
#include <iostream>

class string {
public:
    typedef char* iterator;
    iterator begin() const { return _str; }
    iterator end() const { return _str + _size; }
    void clear() { _str[0] = 0; _size = 0; }
    void reserve(int n);
    
    // 构造
    string();
    string(const char* str);
    string(const string& ch);
    
    const char* c_str() const { return _str; }
    
    // 赋值
    string& operator=(string str);
    
    // 尾插/追加
    void PushBack(const char ch);
    void Append(const char* str);
    
    // 插入/删除
    void Insert(int pos, const char ch);
    void Insert(int pos, const char* str);
    void erase(size_t pos, size_t len);
    string substr(size_t pos, size_t len) const;
    
    // 查找
    size_t find(char ch, size_t pos = 0);
    size_t find(const char* str, size_t pos = 0);
    
    // 复合赋值
    void operator+=(const char* str) { Append(str); }
    void operator+=(const char ch) { PushBack(ch); }
    
    char operator[](int pos) { assert(pos >= 0 && pos < _size); return _str[pos]; }
    int size() { return _size; }
    int capacity() { return _capacity; }
    
    ~string();
    
private:
    char* _str;
    int _size;
    int _capacity;
    static const size_t npos;
};

// 全局运算符声明
bool operator<(const string& s1, const string& s2);
bool operator<=(const string& s1, const string& s2);
bool operator>(const string& s1, const string& s2);
bool operator>=(const string& s1, const string& s2);
bool operator==(const string& s1, const string& s2);
bool operator!=(const string& s1, const string& s2);
std::ostream& operator<<(std::ostream& out, const string& s);
std::istream& operator>>(std::istream& in, string& s);

实现文件 (string.cpp)

#include "string.h"

const size_t string::npos = -1;

void string::reserve(int n) {
    if (n > _capacity) {
        char* temp = new char[n + 1];
        strcpy(temp, _str);
        delete[] _str;
        _str = temp;
        _capacity = n;
    }
}

string::string() {
    _str = new char[1]{\0};
    _size = _capacity = 0;
}

string::string(const char* str) {
    int len = strlen(str);
    _str = new char[len + 1];
    strcpy(_str, str);
    _size = _capacity = len;
}

string::string(const string& ch) {
    _str = new char[ch._capacity + 1];
    strcpy(_str, ch._str);
    _size = ch._size;
    _capacity = ch._capacity;
}

string& string::operator=(string str) {
    Swap(str);
    return *this;
}

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

void string::PushBack(const char ch) {
    if (_size == _capacity) {
        reserve(_capacity == 0 ? 4 : 2 * _capacity);
    }
    _str[_size++] = ch;
    _str[_size] = 0;
}

void string::Append(const char* str) {
    int len = strlen(str);
    if (_size + len > _capacity) {
        reserve(_size + len > 2 * _capacity ? _size + len : 2 * _capacity);
    }
    strcpy(_str + _size, str);
    _size += len;
}

void string::Insert(int pos, const char ch) {
    assert(pos <= _size && pos >= 0);
    if (_size == _capacity) {
        reserve(_capacity == 0 ? 4 : 2 * _capacity);
    }
    int cur = _size;
    while (cur >= pos) {
        _str[cur + 1] = _str[cur];
        cur--;
    }
    _str[pos] = ch;
    _size++;
}

void string::Insert(int pos, const char* str) {
    assert(pos <= _size && pos >= 0);
    int len = strlen(str);
    if (_size + len > _capacity) {
        reserve(_size + len > 2 * _capacity ? _size + len : 2 * _capacity);
    }
    int cur = _size;
    while (cur >= pos) {
        _str[cur + len] = _str[cur];
        cur--;
    }
    strncpy(_str + pos, str, len);
    _size += len;
}

void string::erase(size_t pos, size_t len) {
    assert(pos >= 0 && pos < _size);
    if (len >= _size - pos) {
        _str[pos] = 0;
        _size -= (_size - pos);
    } else {
        while (pos + len <= _size) {
            _str[pos] = _str[pos + len];
            pos++;
        }
        _size -= len;
    }
}

string string::substr(size_t pos, size_t len) const {
    assert(pos >= 0 && pos < _size);
    if (len > _size - pos) {
        len = _size - pos;
    }
    string temp;
    for (int i = pos; i < pos + len; i++) {
        temp += _str[i];
    }
    return temp;
}

size_t string::find(char ch, size_t pos) {
    assert(pos < _size);
    for (int i = pos; i < _size; i++) {
        if (_str[i] == ch) return i;
    }
    return npos;
}

size_t string::find(const char* str, size_t pos) {
    assert(pos < _size);
    char* ret = strstr(_str + pos, str);
    if (ret != nullptr) return ret - _str;
    return npos;
}

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;
}

bool operator!=(const string& s1, const string& s2) {
    return !(s1 == s2);
}

bool operator<=(const string& s1, const string& s2) {
    return s1 < s2 || s1 == s2;
}

bool operator>(const string& s1, const string& s2) {
    return !(s1 <= s2);
}

bool operator>=(const string& s1, const string& s2) {
    return !(s1 < s2);
}

std::ostream& operator<<(std::ostream& out, const string& s) {
    for (auto ch : s) { out << ch; }
    return out;
}

std::istream& operator>>(std::istream& in, string& s) {
    s.clear();
    const int N = 256;
    char buff[N];
    int i = 0;
    char ch;
    ch = in.get();
    while (ch != ' ' && ch != '\n') {
        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;
}