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

三、功能接口实现

3.1 reserve

reserve 仅修改 _capacity，提前分配内存以避免后续频繁扩容。它不改变有效长度 _size，也不填充额外字符。

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

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

坑点提示：切勿在构造函数中调用 reserve。此时成员变量尚未初始化，直接访问可能导致非法访问或逻辑错误。

3.2 c_str

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

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

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

3.3 PushBack

在末尾添加字符，长度加 1。若空间不足需扩容。

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

注意判断 _capacity 是否为 0，避免新空间大小一直为 0。

3.4 Append

在末尾追加字符串。追加前检查 _size + 追加长度 > _capacity，满足则触发扩容。

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 倍扩容，平衡性能与内存。

3.5 Insert

在指定位置插入字符或字符串。插入会导致后续字符后移，时间复杂度较高。

// 插入字符
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 一并拷贝进去破坏原有结构。

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

3.7 substr

截取子串。关键点：返回值是对象，会调用拷贝构造。若未显式定义深拷贝，编译器生成的浅拷贝会导致同一内存被析构两次，引发崩溃。

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

务必确保拷贝构造实现了深拷贝，为新对象重新开辟内存。

3.8 Find

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

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

使用 strstr 查找子串时，需计算指针差值转换为下标。

四、运算符重载

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

传值参数自动触发拷贝构造生成临时对象，交换资源后临时对象析构完成清理。此方式天然支持自赋值，无需额外判断。

4.2 比较运算符

利用 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 指针。

4.3 += 运算符

void operator+=(const char* str) { Append(str); }
void operator+=(const char ch) { PushBack(ch); }

4.4 流输入输出 (<< >>)

输出较简单，遍历字符写入流。输入需注意缓冲区处理，读取到空格或换行停止。

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

同样，这两个函数声明不应放在类内。

五、完整代码汇总

以下是头文件与实现文件的整合示例：

#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) { 
        if (n > _capacity) { 
            char* temp = new char[n+1]; 
            strcpy(temp, _str); 
            delete[] _str; 
            _str = temp; 
            _capacity = n; 
        } 
    }
    string() { _str = new char[1]{\0}; _size = _capacity = 0; }
    string(const char* str) { 
        int len = strlen(str); 
        _str = new char[len + 1]; 
        strcpy(_str, str); 
        _size = _capacity = len; 
    }
    string(const string& ch) { 
        _str = new char[ch._capacity + 1]; 
        strcpy(_str, ch._str); 
        _size = ch._size; 
        _capacity = ch._capacity; 
    }
    const char* c_str() const { return _str; }
    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; }
    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() { delete[] _str; _str = NULL; _size = _capacity = 0; }
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);

#include"string.h"
const size_t string::npos = -1;

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