C++字符串类实现：从内存管理到中文处理-嵌云网-嵌入式AI开发资源站

C++字符串类实现：从内存管理到中文处理

外币兑换

1. 深入理解字符串类的底层实现

在C++开发中，字符串处理是最基础也是最频繁的操作之一。虽然标准库提供了功能强大的std::string类，但手动实现一个字符串类对于理解C++的核心概念至关重要。今天，我将分享一个完整的MyString类实现，从内存管理到运算符重载，带你深入字符串的底层世界。

1.1 为什么需要自定义字符串类

标准库的std::string固然强大，但它隐藏了很多实现细节。通过手动实现MyString类，我们可以：

深入理解C++的内存管理机制
掌握运算符重载的实际应用
学习拷贝控制和对象生命周期管理
理解字符串操作的底层实现原理
为特定场景（如中文处理）定制功能

1.2 MyString类的设计目标

我们的MyString类需要实现以下核心功能：

基本字符串操作（构造、拷贝、析构）
常用字符串处理（查找、替换、拼接等）
运算符重载（赋值、比较、输入输出等）
特殊功能（中文GBK编码处理）
类型转换（与std::string互转）

2. MyString类的核心实现

2.1 内存管理：构造与析构

字符串类的核心挑战在于内存管理。我们需要确保在对象生命周期内正确分配和释放内存。

2.1.1 构造函数实现

cpp复制// 无参构造函数
MyString::MyString() {
    len = 0;
    str = new char[1]; // 至少分配1字节存'\0'
    str[0] = '\0';
}

// 带参构造函数
MyString::MyString(const char* const cstr) {
    if (cstr == NULL) {
        len = 0;
        str = new char[1];
        str[0] = '\0';
    } else {
        len = strlen(cstr);
        str = new char[len+1]; // +1存'\0'
        for (int i = 0; i < len; i++) {
            str[i] = cstr[i];
        }
        str[len] = '\0';
    }
}

// 拷贝构造函数
MyString::MyString(const MyString& s1) {
    if (s1.str == NULL) {
        len = 0;
        str = new char[1];
        str[0] = '\0';
    } else {
        len = strlen(s1.str);
        str = new char[len + 1];
        for (int i = 0; i < len; i++) {
            str[i] = s1.str[i];
        }
        str[len] = '\0';
    }
}

关键点：

无参构造需要分配最小内存（1字节）存储空字符串
带参构造需要处理NULL指针的情况
拷贝构造必须实现深拷贝，避免多个对象共享同一块内存

2.1.2 析构函数实现

cpp复制MyString::~MyString() {
    if(str)
        delete[]str; // 释放数组内存
    len = 0;
}

注意事项：

必须检查str是否为NULL再释放
使用delete[]释放数组内存
重置长度为0是良好的编程习惯

2.2 运算符重载

运算符重载让我们的类用起来像内置类型一样自然。

2.2.1 赋值运算符

cpp复制MyString& MyString::operator=(MyString const& s) {
    if (this == &s) return *this; // 自赋值检查
    
    delete[] str; // 释放原有内存
    
    if (s.str == NULL) {
        len = 0;
        str = new char[1];
        str[0] = '\0';
    } else {
        len = s.len;
        str = new char[len+1];
        for (int i = 0; i < len; i++) {
            str[i] = s.str[i];
        }
        str[len] = '\0';
    }
    return *this;
}

优化点：

添加自赋值检查避免不必要的操作
先释放原有内存再分配新内存
返回引用支持链式赋值

2.2.2 拼接运算符

cpp复制MyString MyString::operator+(MyString const& s) {
    MyString result;
    result.len = len + s.len;
    result.str = new char[result.len + 1];
    
    // 拷贝当前字符串内容
    for (int i = 0; i < len; i++) {
        result.str[i] = str[i];
    }
    
    // 拷贝待拼接字符串内容
    for (int i = 0; i < s.len; i++) {
        result.str[len + i] = s.str[i];
    }
    
    result.str[result.len] = '\0';
    return result;
}

性能考虑：

创建临时对象而非修改原对象
一次性分配足够内存
分两步拷贝保证正确性

2.3 字符串操作实现

2.3.1 字符串替换

cpp复制MyString& MyString::replace(int start, int wide, MyString s) {
    // 参数有效性检查
    if (start < 0) start = 0;
    if (start > len) return *this += s;
    
    // 计算实际删除长度
    int deleteLen = (wide < 0) ? 0 : wide;
    if (start + deleteLen > len) deleteLen = len - start;
    
    // 分配新内存
    int newLen = len - deleteLen + s.len;
    char* newStr = new char[newLen + 1];
    
    // 拷贝三部分内容
    int idx = 0;
    // 1. 起始部分
    for (int i = 0; i < start; i++) newStr[idx++] = str[i];
    // 2. 替换部分
    for (int i = 0; i < s.len; i++) newStr[idx++] = s.str[i];
    // 3. 剩余部分
    for (int i = start + deleteLen; i < len; i++) newStr[idx++] = str[i];
    
    newStr[newLen] = '\0';
    
    // 更新对象状态
    delete[] str;
    str = newStr;
    len = newLen;
    
    return *this;
}

边界处理：

处理负数和越界的start参数
计算合理的删除长度
分三部分拷贝保证正确性

2.3.2 字符串查找

cpp复制int MyString::findString(MyString& substr) {
    int len1 = len;
    int len2 = substr.len;
    
    if (len2 == 0) return 0; // 空子串默认匹配位置0
    
    for (int i = 0; i <= len1 - len2; i++) {
        int j = 0;
        while (j < len2 && str[i + j] == substr.str[j]) j++;
        if (j == len2) return i; // 完全匹配
    }
    
    return -1; // 未找到
}

算法选择：

使用简单的暴力匹配算法
可以优化为KMP等更高效算法
处理空子串的特殊情况

2.4 中文GBK编码处理

GBK编码中一个中文字符占2字节，需要特殊处理。

2.4.1 判断中文字符

cpp复制bool isGBKChineseStart(unsigned char c) {
    return (c >= 0x81 && c <= 0xFE);
}

GBK编码规则：

首字节范围：0x81~0xFE
次字节范围：0x40~0xFE（不含0x7F）

2.4.2 中文分词处理

cpp复制std::vector<std::string> extractChineseGBK(const std::string& str) {
    std::vector<std::string> words;
    for (size_t i = 0; i < str.length();) {
        if (isGBKChineseStart(static_cast<unsigned char>(str[i]))) {
            // 提取2字节的中文字符
            words.push_back(str.substr(i, 2));
            i += 2;
        } else {
            ++i;
        }
    }
    return words;
}

处理逻辑：

遍历字符串识别中文字符起始字节
每次提取2字节作为一个中文字符
非中文字符按1字节处理

3. 实战应用与性能优化

3.1 MyString类的使用示例

cpp复制#include "MyString.h"

int main() {
    // 1. 构造与基本操作
    MyString s1("Hello");
    MyString s2("World");
    MyString s3 = s1 + " " + s2;
    cout << s3 << endl; // 输出: Hello World
    
    // 2. 查找与替换
    int pos = s3.findString(MyString("World"));
    s3.replace(pos, 5, "C++");
    cout << s3 << endl; // 输出: Hello C++
    
    // 3. 中文处理
    MyString chinese("中文测试");
    Add_Space_In_Chinese_String(chinese);
    cout << chinese << endl; // 输出: 中 文 测 试
    
    return 0;
}

3.2 性能优化建议

内存池技术：频繁的new/delete操作会影响性能，可以使用内存池预分配内存
移动语义：添加移动构造函数和移动赋值运算符，减少不必要的拷贝
缓冲区优化：实现类似std::string的capacity概念，减少内存重新分配
算法优化：将字符串查找替换为更高效的算法（如KMP）
多线程安全：添加必要的锁机制保证线程安全

3.3 扩展功能建议

正则表达式支持：添加基本的正则匹配功能
编码转换：支持UTF-8等其他编码格式
格式化输出：实现类似printf的格式化功能
迭代器支持：提供STL风格的迭代器接口
内存共享：实现写时复制(Copy-On-Write)优化

4. 常见问题与解决方案

4.1 内存泄漏问题

问题现象：程序运行时间增长后内存不断上升

排查方法：

使用valgrind等工具检测内存泄漏
检查所有new操作是否有对应的delete
确保异常安全，在可能抛出异常的地方使用RAII

解决方案：

cpp复制// 使用智能指针管理内存
class MyString {
private:
    std::unique_ptr<char[]> str;
    int len;
public:
    MyString() : len(0), str(new char[1]) {
        str[0] = '\0';
    }
    // 其他成员函数...
};

4.2 性能瓶颈

问题现象：字符串拼接操作特别慢

原因分析：每次拼接都重新分配内存并拷贝内容

优化方案：

cpp复制// 预分配缓冲区的拼接实现
MyString& MyString::operator+=(const MyString& s) {
    if (s.len == 0) return *this;
    
    int newLen = len + s.len;
    char* newStr = new char[newLen + 1];
    
    // 拷贝原内容
    memcpy(newStr, str, len);
    // 拷贝新内容
    memcpy(newStr + len, s.str, s.len);
    
    newStr[newLen] = '\0';
    
    delete[] str;
    str = newStr;
    len = newLen;
    
    return *this;
}

4.3 中文处理异常

问题现象：处理中英文混合字符串时出现乱码

原因分析：未正确处理GBK编码的中英文字符混合情况