C++字符串类设计与内存管理实践

王端端

1. 从StringBad到String：一个C++字符串类的进化之路

在C++开发中，字符串处理是最基础也最常遇到的任务之一。很多初学者在掌握了基本语法后，第一个尝试实现的类往往就是字符串类。今天我要分享的是一个从简陋的StringBad类逐步完善为功能完备的String类的完整过程，这个案例几乎涵盖了C++类设计的核心知识点。

这个String类最初版本存在严重的内存管理问题，经过多次迭代后，它现在具备了：

安全的动态内存管理
完整的拷贝控制（拷贝构造、赋值运算符）
丰富的字符串操作功能
运算符重载
静态成员管理

让我们从最关键的改进点开始，逐步剖析这个类的设计思路和实现细节。

2. 核心改进：内存管理与拷贝控制

2.1 默认构造函数的优化

原始版本的默认构造函数存在两个问题：一是会产生不必要的调试输出，二是初始化内容不必要地复杂。改进后的版本简洁而安全：

cpp复制String::String()
{
    len = 0;
    str = new char[1];
    str[0] = '\0';  // 空字符串
}

这里有几个值得注意的技术细节：

即使创建空字符串，我们也分配了1字节的内存而不是直接赋nullptr，这是为了与析构函数中的delete[]操作保持兼容
使用len明确记录字符串长度，避免反复调用strlen
确保字符串以'\0'结尾，符合C风格字符串规范

关键经验：在C++中，构造函数和析构函数的内存管理操作必须严格匹配。new/delete、new[]/delete[]必须成对使用。

2.2 拷贝构造函数与赋值运算符

原始类最大的问题就是缺少正确的拷贝控制，导致浅拷贝问题。改进版本实现了深拷贝：

cpp复制// 拷贝构造函数
String::String(const String& st)
{
    num_strings++;
    len = st.len;
    str = new char[len + 1];
    std::strcpy(str, st.str);
}

// 赋值运算符
String& String::operator=(const String& st)
{
    if (this == &st)  // 自赋值检查
        return *this;
        
    delete[] str;  // 释放原有内存
    len = st.len;
    str = new char[len + 1];
    std::strcpy(str, st.str);
    return *this;
}

这里有几个关键点：

拷贝构造函数需要递增静态计数器num_strings
赋值运算符必须处理自赋值情况（a = a）
必须先释放旧内存再分配新内存
返回*this以支持链式赋值（a = b = c）

3. 功能增强：运算符重载与实用方法

3.1 比较运算符的实现

为了让String类用起来像内置类型一样自然，我们重载了比较运算符：

cpp复制bool operator<(const String& st1, const String& st2)
{
    return (std::strcmp(st1.str, st2.str) < 0);
}

bool operator>(const String& st1, const String& st2)
{
    return st2 < st1;  // 巧妙地复用<运算符
}

bool operator==(const String& st1, const String& st2)
{
    return (std::strcmp(st1.str, st2.str) == 0);
}

实现技巧：

基于strcmp实现，确保与C风格字符串行为一致
通过复用已有运算符减少代码重复
声明为友元函数以支持隐式转换

3.2 下标访问运算符

为了支持类似数组的访问方式，我们实现了两个版本的下标运算符：

cpp复制// 普通版本，允许修改
char& String::operator[](int i)
{
    return str[i];
}

// const版本，用于const对象
const char& String::operator[](int i) const
{
    return str[i];
}

这种成对出现的运算符重载是C++的常见模式：

非常量版本返回char&，支持修改
const版本返回const char&，保证安全性
编译器会根据对象const性质自动选择合适版本

3.3 输入输出运算符

为了让String类完美融入C++IO系统，我们重载了<<和>>运算符：

cpp复制ostream& operator<<(ostream& os, const String& st)
{
    os << st.str;
    return os;
}

istream& operator>>(istream& is, String& st)
{
    char temp[String::CINLIM];
    is.get(temp, String::CINLIM);
    if (is)
        st = temp;
    while (is && is.get() != '\n')
        continue;
    return is;
}

实现要点：

使用get而不是>>读取一行输入，避免空格截断
设置合理的输入限制(CINLIM)
处理输入缓冲区中的剩余字符
支持链式调用（return stream对象）

4. 高级特性：静态成员与直接C字符串赋值

4.1 静态成员管理

String类使用静态成员跟踪创建的字符串数量：

cpp复制static int num_strings;  // 类内声明

int String::num_strings = 0;  // 类外初始化

static int HowMany() { return num_strings; }  // 静态方法

静态成员的特点：

被所有类实例共享
必须在类外单独初始化（int类型可以类内初始化）
静态方法只能访问静态成员

4.2 直接C字符串赋值

为了避免从C字符串创建临时String对象的开销，我们增加了直接赋值运算符：

cpp复制String& String::operator=(const char* s)
{
    delete[] str;
    len = std::strlen(s);
    str = new char[len + 1];
    std::strcpy(str, s);
    return *this;
}

这种优化在性能敏感的场景特别有用，它消除了临时对象的构造和析构开销。

5. 使用示例与经验总结

5.1 完整使用示例

cpp复制int main()
{
    String name;
    cout << "Enter your name: ";
    cin >> name;
    
    String sayings[3];
    cout << "Enter 3 sayings:\n";
    for (int i = 0; i < 3; i++) {
        cin >> sayings[i];
    }
    
    // 找出最短的和字典序最小的
    int shortest = 0, first = 0;
    for (int i = 1; i < 3; i++) {
        if (sayings[i].length() < sayings[shortest].length())
            shortest = i;
        if (sayings[i] < sayings[first])
            first = i;
    }
    
    cout << "Shortest: " << sayings[shortest] << endl;
    cout << "First alphabetically: " << sayings[first] << endl;
    cout << "Total String objects: " << String::HowMany() << endl;
}