1. 从零构建C++字符串类的必要性
在C++开发中，字符串操作是最基础也最频繁的需求。虽然标准库提供了成熟的std::string，但自己实现一个String类对于理解以下核心概念至关重要：
内存管理机制：C++不像Java有自动垃圾回收，动态内存的分配与释放完全由程序员控制。字符串类需要管理字符数组的生命周期，这涉及到：
- 构造函数中的内存分配
- 析构函数中的内存释放
- 拷贝时的深拷贝处理
运算符重载实践：通过重载运算符可以让自定义类型拥有内置类型般的操作体验。字符串类通常需要重载：
- 赋值运算符(=)
- 比较运算符(==, !=, <, >)
- 下标运算符([])
- 输入输出运算符(<<, >>)
面向对象设计原则：良好的类设计需要考虑：
- 访问控制（public/protected/private）
- const正确性
- 异常安全
- 静态成员的使用
我在实际项目中发现，即使是有经验的C++开发者，在实现字符串类时也常犯两个错误：1) 忘记处理自赋值情况 2) 没有为[]运算符提供const版本。这些细节正是面试中的考察重点。
2. 类设计蓝图与内存模型
2.1 类声明解析
我们先看完整的类声明，这是后续实现的基础框架：
cpp复制// string1.h
#ifndef STRING1_H_
#define STRING1_H_
#include <iostream>
using std::ostream;
using std::istream;
class String {
private:
char* str; // 动态分配的字符数组
int len; // 字符串长度(不含'\0')
static int num_strings; // 对象计数器
static const int CINLIM = 80; // 输入长度限制
public:
// 构造与析构
String(const char* s = nullptr); // 通用构造函数
String(const String&); // 拷贝构造
~String(); // 析构函数
// 赋值运算符
String& operator=(const String&);
String& operator=(const char*);
// 访问方法
int length() const { return len; }
char& operator[](int i);
const char& operator[](int i) const;
// 友元比较函数
friend bool operator<(const String&, const String&);
friend bool operator>(const String&, const String&);
friend bool operator==(const String&, const String&);
// 输入输出
friend ostream& operator<<(ostream&, const String&);
friend istream& operator>>(istream&, String&);
// 静态方法
static int HowMany();
};
#endif
2.2 内存布局示意图
理解对象的内存模型对正确实现至关重要：
code复制String对象内存布局：
+-------------------+
| str (指针) | --> 堆内存 [H][e][l][l][o][\0]
+-------------------+
| len (int) | = 5
+-------------------+
| (隐含的this指针) |
+-------------------+
静态区：
+-------------------+
| num_strings (int) | = 当前对象计数
+-------------------+
3. 核心实现细节剖析
3.1 构造函数家族
默认构造与通用构造的合并技巧：
cpp复制String::String(const char* s) {
if (s) {
len = strlen(s);
str = new char[len + 1];
strcpy(str, s);
} else {
len = 0;
str = new char[1];
str[0] = '\0';
}
num_strings++;
}
这种实现将默认构造和C字符串构造合二为一，通过参数默认值（头文件中设为nullptr）简化接口。注意new char[1]而非new char的细节，确保与delete[]的配对使用。
拷贝构造的深拷贝实现：
cpp复制String::String(const String& st) {
len = st.len;
str = new char[len + 1]; // 独立分配内存
strcpy(str, st.str); // 内容复制
num_strings++;
}
3.2 赋值运算符的陷阱与解决方案
赋值运算符需要考虑三种特殊情况：
- 自赋值（a = a）
- 异常安全
- 内存泄漏
改进后的安全实现：
cpp复制String& String::operator=(const String& st) {
if (this == &st) return *this; // 自赋值检查
char* temp = new char[st.len + 1]; // 先分配新内存
strcpy(temp, st.str); // 再复制内容
delete[] str; // 释放旧内存
str = temp; // 指向新内存
len = st.len;
return *this; // 支持链式赋值
}
这种实现保证了异常安全——如果new抛出异常，原对象状态保持不变。同时处理了自赋值情况，避免释放后立即使用的错误。
3.3 下标运算符的双重版本
cpp复制// 可修改版本
char& String::operator[](int i) {
if (i < 0 || i >= len)
throw std::out_of_range("Invalid index");
return str[i];
}
// const版本
const char& String::operator[](int i) const {
if (i < 0 || i >= len)
throw std::out_of_range("Invalid index");
return str[i];
}
const版本允许对const对象进行只读访问，这是良好的const正确性实践。添加边界检查可避免缓冲区溢出漏洞。
4. 进阶特性实现
4.1 静态成员管理
静态成员需要在类外单独初始化：
cpp复制// string1.cpp
int String::num_strings = 0; // 必须在.cpp文件中初始化
int String::HowMany() {
return num_strings;
}
静态成员的特点：
- 所有对象共享同一实例
- 不属于任何特定对象
- 静态方法只能访问静态成员
4.2 输入输出运算符重载
输出运算符实现：
cpp复制ostream& operator<<(ostream& os, const String& st) {
os << st.str; // 直接输出内部字符数组
return os;
}
输入运算符的健壮实现：
cpp复制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;
}
这种实现避免了直接操作st的内部成员，复用现有接口更安全。同时处理了输入过长和缓冲区清理问题。
5. 测试与验证策略
5.1 单元测试要点
完整的测试应覆盖以下场景：
cpp复制void test_String() {
// 构造测试
String s1; // 默认构造
String s2("Hello"); // C字符串构造
String s3 = s2; // 拷贝构造
// 赋值测试
s1 = s3; // 对象赋值
s1 = "World"; // C字符串赋值
s1 = s1; // 自赋值
// 访问测试
assert(s2.length() == 5);
assert(s2[0] == 'H');
s2[0] = 'h'; // 修改测试
// 比较测试
assert(s2 < s3);
assert(s1 == "World");
// 静态成员测试
assert(String::HowMany() == 3);
}
5.2 内存泄漏检测
使用Valgrind或AddressSanitizer检查内存问题：
bash复制g++ -fsanitize=address -g test_string.cpp string1.cpp -o test
./test
正确的实现应该显示"0 errors"的内存报告。
6. 性能优化方向
6.1 写时复制(Copy-On-Write)
进阶实现可以采用COW技术减少拷贝开销：
cpp复制class String {
private:
struct StringValue {
int refcount;
char* data;
// ... 其他成员
};
StringValue* value;
// ... 其他成员
};
当多个String对象共享相同内容时，只在修改时才创建副本。这需要更复杂的引用计数管理。
6.2 短字符串优化(SSO)
对于短字符串，可以直接存储在对象内部避免堆分配：
cpp复制class String {
private:
static const int SSO_LIMIT = 15;
union {
char* ptr;
char sso_buffer[SSO_LIMIT + 1];
};
size_t length;
// ... 其他成员
};
当字符串长度<=15时使用栈存储，否则使用堆存储。这是std::string常用的优化技术。
7. 常见问题与解决方案
7.1 为什么我的String类在vector中崩溃？
典型问题场景：
cpp复制std::vector<String> vec;
vec.push_back(String("test")); // 可能崩溃
原因分析：
- 没有正确实现移动语义(C++11后)
- vector扩容时发生拷贝，如果拷贝构造实现不正确会导致问题
解决方案：
- 确保拷贝构造正确实现深拷贝
- 添加移动构造和移动赋值(C++11)
cpp复制// 移动构造
String::String(String&& other) noexcept
: str(other.str), len(other.len) {
other.str = nullptr;
other.len = 0;
}
// 移动赋值
String& String::operator=(String&& other) noexcept {
if (this != &other) {
delete[] str;
str = other.str;
len = other.len;
other.str = nullptr;
other.len = 0;
}
return *this;
}
7.2 如何实现线程安全？
在多线程环境下，静态成员num_strings需要保护：
cpp复制class String {
private:
static std::atomic<int> num_strings;
// ... 其他成员
};
// 使用时无需额外同步
String::String() {
++num_strings; // 原子操作
// ... 其他初始化
}
使用atomic比mutex性能更好，适合这种简单的计数器场景。
8. 与现代C++特性的结合
8.1 使用智能指针管理内存
可以改用unique_ptr自动管理内存：
cpp复制class String {
private:
std::unique_ptr<char[]> str;
// ... 其他成员
};
// 构造函数示例
String::String(const char* s)
: str(std::make_unique<char[]>(strlen(s) + 1)) {
strcpy(str.get(), s);
// ... 其他初始化
}
这样就不需要手动实现析构函数，但拷贝操作仍需自定义。
8.2 添加迭代器支持
使String兼容STL算法：
cpp复制class String {
public:
using iterator = char*;
using const_iterator = const char*;
iterator begin() { return str; }
iterator end() { return str + len; }
// ... const版本
};
// 使用示例
String s("hello");
std::reverse(s.begin(), s.end());
9. 与Java String的对比理解
虽然都是字符串类，但C++实现与Java有本质区别：
| 特性 | C++ String | Java String |
|---|---|---|
| 内存管理 | 手动 | 自动GC |
| 可变性 | 可变 | 不可变 |
| 拷贝语义 | 深拷贝(默认) | 引用拷贝 |
| 内存布局 | 直接存储字符数组 | 使用char[] |
| 线程安全 | 需手动实现 | 天生线程安全 |
理解这些差异有助于在两种语言间切换时避免常见错误。