C++ string 类从原理到实战

#include <iostream>
#include <cstring>
#include <assert.h>
using namespace std;
class MyString {
private:
    char* _str;
    size_t _size;
    size_t _capacity;
public:
    // 构造函数
    MyString(const char* str) {
        if (str == nullptr) {
            _str = nullptr;
            _size = 0;
            _capacity = 0;
        } else {
            _size = strlen(str);
            _capacity = _size;
            _str = new char[_capacity + 1];
            strcpy(_str, str);
        }
    }
    // 拷贝构造（深拷贝）
    MyString(const MyString& other) {
        _size = other._size;
        _capacity = other._capacity;
        _str = new char[_capacity + 1];
        memcpy(_str, other._str, _size + 1);
    }
    // 赋值运算符（现代写法）
    MyString& operator=(MyString tmp) {
        swap(tmp);
        return *this;
    }
    // 移动赋值（C++11，转移资源）
    MyString& operator=(MyString&& other) noexcept {
        if (this != &other) {
            delete[] _str;
            _str = other._str;
            _size = other._size;
            _capacity = other._capacity;
            other._str = nullptr;
        }
        return *this;
    }
    // 析构函数
    ~MyString() {
        delete[] _str;
        _str = nullptr;
        _size = _capacity = 0;
    }
    // 交换成员
    void swap(MyString& s) {
        std::swap(_str, s._str);
        std::swap(_size, s._size);
        std::swap(_capacity, s._capacity);
    }
};

4.2 比较运算符重载（> < >= <= == !=）

基于strcmp实现字典序比较：

bool operator>(const MyString& other) const {
    return strcmp(_str, other._str) > 0;
}
bool operator<(const MyString& other) const {
    return strcmp(_str, other._str) < 0;
}
bool operator>=(const MyString& other) const {
    return !(*this < other);
}
bool operator<=(const MyString& other) const {
    return !(*this > other);
}
bool operator==(const MyString& other) const {
    return strcmp(_str, other._str) == 0;
}
bool operator!=(const MyString& other) const {
    return !(*this == other);
}

4.3 resize 函数实现

调整字符串长度，支持缩小、扩大与填充字符：

void resize(size_t new_size, char fill_char = '\0') {
    if (new_size < _size) {
        _size = new_size;
        _str[_size] = '\0';
    } else {
        reserve(new_size);
        for (size_t i = _size; i < new_size; ++i) {
            _str[i] = fill_char;
        }
        _size = new_size;
        _str[_size] = '\0';
    }
}
// 预留容量
void reserve(size_t n) {
    if (n > _capacity) {
        char* new_str = new char[n + 1];
        strcpy(new_str, _str);
        delete[] _str;
        _str = new_str;
        _capacity = n;
    }
}

4.4 + 运算符重载（字符串拼接）

支持MyString + MyString、MyString + const char*：

MyString operator+(const MyString& other) const {
    size_t new_size = _size + other._size;
    char* new_data = new char[new_size + 1];
    strcpy(new_data, _str);
    strcat(new_data, other._str);
    MyString res(new_data);
    delete[] new_data;
    return res;
}
MyString operator+(const char* str) const {
    size_t len = strlen(str);
    size_t new_size = _size + len;
    char* new_data = new char[new_size + 1];
    strcpy(new_data, _str);
    strcat(new_data, str);
    MyString res(new_data);
    delete[] new_data;
    return res;
}

4.5 迭代器实现（简单模拟）

string迭代器本质是字符指针：

typedef char* iterator;
typedef const char* const_iterator;
iterator begin() {
    return _str;
}
iterator end() {
    return _str + _size;
}
const_iterator begin() const {
    return _str;
}
const_iterator end() const {
    return _str + _size;
}

五、标准库 string 常用函数详解

5.1 初始化方式

string s0; // 空字符串
string s1("hello"); // 字面量初始化
string s2 = s1; // 拷贝初始化
string s3(5, 'a'); // 重复字符："aaaaa"

5.2 容量与长度

• size()/length()：返回字符串长度（功能完全一致）
• capacity()：返回已分配内存容量
• reserve(n)：预分配容量，减少扩容
• shrink_to_fit()：释放多余内存，使容量等于长度
• clear()：清空字符串内容，不释放内存

5.3 字符串操作

1. 拼接：+=、append()
2. 查找：find()、rfind()、find_first_of()（未找到返回string::npos）
3. 子串：substr(pos, len)（省略len取到末尾）
4. 替换：replace(pos, len, str)
5. 插入 / 删除：insert()、erase()（效率低，少用）
6. 字符访问：[]（不检查越界）、at()（越界抛异常）

5.4 数值与字符串转换

• 数值→字符串：to_string()（C++11，标准通用）
• 字符串→整数：atoi()（C 风格）、stoi()（C++11，抛异常）
• 通用转换：stringstream（跨平台、支持任意类型）

5.5 输入输出

• cin：以空格 / 换行分隔，无法读取带空格字符串
• getline(cin, str)：读取整行，包含空格（需处理前导换行符）

cin.ignore(); // 清空缓冲区换行
geline(cin, str);

六、迭代器与容器配合

6.1 string 遍历方式

1. 下标遍历

for (size_t i = 0; i < s.size(); ++i) cout << s[i];

1. 迭代器遍历

string::iterator it = s.begin();
while (it != s.end()) cout << *it++;

1. 反向迭代器

string::reverse_iterator rit = s.rbegin();
while (rit != s.rend()) cout << *rit++;

1. 范围 for 循环（简洁推荐）

for (auto& ch : s) cout << ch;

6.2 STL 算法配合

需包含<algorithm>：

reverse(s.begin(), s.end()); // 反转
sort(s.begin(), s.end()); // 排序

七、实战案例：字符串数字相加

处理超大数字（超出整型范围），模拟手工加法：

#include <iostream>
#include <string>
#include <algorithm>
using namespace std;
string addStrings(string num1, string num2) {
    int i = num1.size() - 1, j = num2.size() - 1;
    string res;
    int carry = 0;
    while (i >= 0 || j >= 0 || carry) {
        int val1 = i >= 0 ? num1[i--] - '0' : 0;
        int val2 = j >= 0 ? num2[j--] - '0' : 0;
        int sum = val1 + val2 + carry;
        carry = sum / 10;
        res.push_back(sum % 10 + '0');
    }
    reverse(res.begin(), res.end());
    return res;
}
// 测试
int main() {
    cout << addStrings("123456789", "987654321") << endl; // 1111111110
    return 0;
}

八、总结

1. 深浅拷贝：浅拷贝共享内存易崩溃，深拷贝独立内存更安全，string默认深拷贝。
2. 自定义string：需实现构造、析构、拷贝构造、赋值运算符，重载常用运算符与迭代器。
3. 标准string：接口丰富，优先使用+=、reserve优化性能，注意find、substr边界。
4. 迭代器：是 STL 容器通用访问方式，配合算法可高效操作字符串。
5. 实战：字符串数字相加核心为逆序逐位相加 + 处理进位 + 反转结果，适用于超大数运算。