搞懂 C++ 的 std::string：接口、拷贝与那些面试官爱问的细节

表格太死板，随手记：string(size_t n, char c) 是 n 个重复字符；拷贝构造会深拷贝（现代实现大多是贪婪的，不是写时拷贝了）。

容量

size() 和 length() 是一回事，返回有效字符数；capacity() 告诉你底层分配了多大的空间；empty() 判空；clear() 把 size() 清成 0，但 capacity() 保留；reserve(n) 预留空间，只在 n > capacity 时才重新分配；resize(n, c) 能改大小，多了拿 c 填充，少了就截断。

string s = "hey";
s.reserve(100);    // size 还是 3，capacity >= 100
s.resize(10, 'x'); // 变成 "heyxxxxxxx"，size = 10

频繁往 string 后面塞字符时，先 reserve 一把能省不少 reallocation 的开销。

访问和遍历

operator[] 不检查越界，和数组一样；要安全就用 at()，越界抛异常。

string s = "hello";
s[0] = 'H';
for (auto it = s.begin(); it != s.end(); ++it) cout << *it;
for (auto rit = s.rbegin(); rit != s.rend(); ++rit) cout << *rit;

迭代器类型有四种：iterator / const_iterator、reverse_iterator / const_reverse_iterator，平常让 auto 推导就行。

修改

push_back 加单字符，append 或 += 连串。c_str() 返回只读的 C 指针，只在对接口有要求时才用。

string s = "Hello";
s.push_back('!');           // "Hello!"
s.append(" World");        // "Hello! World"
s += " to C++";            // "Hello! World to C++"

const char* p = s.c_str();  // 只读，别拿着去 free

查找用 find / rfind，找不到返回 string::npos。截子串用 substr(pos, len)：

size_t p = s.find("World");
if (p != string::npos) {
    string sub = s.substr(p, 6);  // "World"
}

注意 substr 会复制一份新串出来。

还有几个非成员函数：getline(cin, s) 读一整行（带空格），输入流 >> 以空白分隔，operator+ 会生成临时对象，大量拼接时不如 += 快。比较直接用 ==、> 这些，字典序。

string name;
getline(cin, name);  // 能读 "Alice Bob"
if (name > "Alice") { /* ... */ }

编译器底下的小把戏

不同厂商的 string 实现还不一样。32 位下，VS 的 string 一般占 28 字节，内部有个 union，小于 16 字符的串直接存在对象里（小字符串优化），长了才堆分配。G++ 老版本用过写时拷贝（COW），对象里就一个指针，指向堆上一块控制块；但现在的主流实现都从 COW 退出来了，多线程下引用计数的维护太麻烦，改为独占所有权，拷贝时老老实实深拷贝。

手写一个 String 类

面试的时候很可能让你现场撸一个 String，考的就是你怎么处理资源。

浅拷贝惹的祸

新手最容易掉进的坑就是只写了参数化构造和析构，忘了拷贝控制：

class String {
public:
    String(const char* str = nullptr) {
        if (str == nullptr) assert(false);
        _str = new char[strlen(str) + 1];
        strcpy(_str, str);
    }
    ~String() { delete[] _str; }
private:
    char* _str;
};

String s1("hello");
String s2(s1);   // 编译器生成的拷贝构造是浅拷贝，_str 指向同一块内存

s1 和 s2 析构时会对同一块内存 delete 两次，直接崩。

补救就是深拷贝：

String(const String& s) {
    _str = new char[strlen(s._str) + 1];
    strcpy(_str, s._str);
}

赋值：传统 vs 现代

传统赋值写法先 new 一块，复制，再 delete 旧的，还自己处理自赋值：

String& operator=(const String& s) {
    if (this != &s) {
        char* tmp = new char[strlen(s._str) + 1];
        strcpy(tmp, s._str);
        delete[] _str;
        _str = tmp;
    }
    return *this;
}

这种代码虽然直白，但得小心 new 失败时 _str 还是旧状态（虽然这里没异常安全的问题，但 new 会抛 bad_alloc）。

现代写法利用传值自动调用拷贝构造，然后 swap，既简洁又天然处理自赋值和异常安全：

String& operator=(String s) {
    swap(_str, s._str);
    return *this;
}

operator= 的参数按值传递，会触发拷贝构造，函数体内交换指针，函数返回时形参 s 析构，把旧资源释放掉。这个套路也叫 copy-and-swap idiom。

写时拷贝（COW）：曾经的黑魔法

COW 的思想是动时才深拷贝。多个 string 对象共享一块内存，额外维护引用计数。读操作只是增加引用，写的时候发现计数 > 1 才分配新内存并拷贝。这样做能省很多不必要的深拷贝，特别是大字符串频繁传递的时候。

• Linux 的 fork() 就是 COW 的思路，父子进程共享内存，谁写谁复制。
• Redis 持久化 RDB 时，子进程也用 COW 共享父进程数据，减少阻塞。
• Java 的 CopyOnWriteArrayList 在读写分离场景也是这个模式。
• 容器镜像的分层存储，写时复制非常自然。

但它也有坑：写操作可能突然变慢（缺页异常 + 内存分配），而且在多线程里维护引用计数需要原子操作甚至锁，成本不小。这也是为什么现代 C++ 标准库（特别是 C++11 后）普遍放弃了 string 的 COW，直接采用独占所有权 + 小字符串优化。不过了解 COW 对理解内存管理很有帮助。

面试里的实操要点

自己写的 String 类得满足：

• 能赋值、拷贝，行为像值类型。
• 可以作为函数参数和返回值正常传递。
• 可以放进 vector 这样的容器里（要求可拷贝、可赋值，移动语义另说）。

基本上，只要遵守三法则（自定义析构时也要定义拷贝构造和赋值）就 OK。C++11 以后还多了移动构造和移动赋值，但那是后话。

以上就是我对 std::string 核心接口、实现细节和手写要点的一篇梳理。做业务开发时直接调接口就行，但这些底层的知识在踩坑或优化时特别管用。