C++ string 类详解：常用接口、OJ 场景与模拟实现中的深浅拷贝

C++ string 类详解：常用接口、OJ 场景与模拟实现中的深浅拷贝

🔥 星恒随风： 个人主页 ❄️ 个人专栏： 《指针合集》 ｜ 《C语言基础》 ｜ 《数据结构》 ｜ 《机器学习导论》 ｜ 《前端基础》 ｜ 《python基础》 ✨ 数据即知识，压缩即智能

---

C++ string 类详解：常用接口、OJ 场景与模拟实现中的深浅拷贝

目录

• [C++ string 类详解：常用接口、OJ 场景与模拟实现中的深浅拷贝](#C++ string 类详解：常用接口、OJ 场景与模拟实现中的深浅拷贝)
• [C++ string 类详解：常用接口、OJ 场景与模拟实现中的深浅拷贝](#C++ string 类详解：常用接口、OJ 场景与模拟实现中的深浅拷贝)
• • 前言
• [一、string 常见构造方式](#一、string 常见构造方式)
• • [1.1 构造空字符串](#1.1 构造空字符串)
  • [1.2 用 C 字符串构造](#1.2 用 C 字符串构造)
  • [1.3 拷贝构造](#1.3 拷贝构造)
  • [1.4 构造 n 个相同字符](#1.4 构造 n 个相同字符)
• [二、string 的容量相关接口](#二、string 的容量相关接口)
• • [2.1 size 和 length](#2.1 size 和 length)
  • [2.2 capacity](#2.2 capacity)
  • [2.3 empty](#2.3 empty)
  • [2.4 clear](#2.4 clear)
  • [2.5 reserve](#2.5 reserve)
  • [2.6 resize](#2.6 resize)
  • [2.7 reserve 和 resize 的核心区别](#2.7 reserve 和 resize 的核心区别)
• [三、string 的访问和遍历](#三、string 的访问和遍历)
• • [3.1 operator\[\]](#3.1 operator[])
  • [3.2 迭代器遍历](#3.2 迭代器遍历)
  • [3.3 反向迭代器](#3.3 反向迭代器)
  • [3.4 范围 for 遍历](#3.4 范围 for 遍历)
• [四、string 的修改操作](#四、string 的修改操作)
• • [4.1 push_back](#4.1 push_back)
  • [4.2 append](#4.2 append)
  • [4.3 operator+=](#4.3 operator+=)
  • [4.4 operator+ 为什么要少用？](#4.4 operator+ 为什么要少用？)
• [五、string 的查找和截取](#五、string 的查找和截取)
• • [5.1 find](#5.1 find)
  • [5.2 rfind](#5.2 rfind)
  • [5.3 substr](#5.3 substr)
  • [5.4 c_str](#5.4 c_str)
• [六、输入输出：cin、getline 和空格问题](#六、输入输出：cin、getline 和空格问题)
• • [6.1 operator>>](#6.1 operator>>)
  • [6.2 getline](#6.2 getline)
  • [6.3 cin 和 getline 混用时的坑](#6.3 cin 和 getline 混用时的坑)
• [七、几个典型 OJ 字符串场景](#七、几个典型 OJ 字符串场景)
• • [7.1 仅反转字母](#7.1 仅反转字母)
  • [7.2 找第一个只出现一次的字符](#7.2 找第一个只出现一次的字符)
  • [7.3 最后一个单词的长度](#7.3 最后一个单词的长度)
  • [7.4 验证回文串](#7.4 验证回文串)
  • [7.5 字符串相加](#7.5 字符串相加)
• [八、不同编译器下 string 的底层结构](#八、不同编译器下 string 的底层结构)
• • [8.1 string 不是简单的 char*](#8.1 string 不是简单的 char*)
  • [8.2 小字符串优化](#8.2 小字符串优化)
  • [8.3 写时拷贝](#8.3 写时拷贝)
• [九、为什么要模拟实现 String？](#九、为什么要模拟实现 String？)
• [十、一个有问题的 String 类](#十、一个有问题的 String 类)
• 十一、浅拷贝的问题
• • [11.1 什么是浅拷贝？](#11.1 什么是浅拷贝？)
  • [11.2 浅拷贝为什么危险？](#11.2 浅拷贝为什么危险？)
• 十二、深拷贝解决问题
• • [12.1 什么是深拷贝？](#12.1 什么是深拷贝？)
  • [12.2 传统写法：拷贝构造](#12.2 传统写法：拷贝构造)
  • [12.3 传统写法：赋值运算符重载](#12.3 传统写法：赋值运算符重载)
• 十三、现代写法：拷贝交换
• • [13.1 拷贝构造中的交换思想](#13.1 拷贝构造中的交换思想)
  • [13.2 赋值运算符的现代写法](#13.2 赋值运算符的现代写法)
• [十四、String 模拟实现的基本版本](#十四、String 模拟实现的基本版本)
• 十五、本文总结

---

前言

上一篇我们从 STL 的整体结构出发，介绍了 string 在 C++ 标准库中的位置。

这一篇继续深入：

string 到底怎么用？

---

一、string 常见构造方式

1.1 构造空字符串

string s1;

这会构造一个空字符串。

此时：

s1.size() == 0
s1.empty() == true

---

1.2 用 C 字符串构造

string s2("hello bit");

或者：

string s2 = "hello bit";

这是最常用的构造方式。

相比 C 字符数组，string 会自己管理内部空间。

---

1.3 拷贝构造

string s3(s2);

或者：

string s3 = s2;

这会用已有的 string 对象构造新对象。

从使用层面看，就是复制一份字符串内容。

从实现层面看，现代 string 通常需要保证两个对象的内容独立管理，避免浅拷贝导致的重复释放问题。

---

1.4 构造 n 个相同字符

string s4(5, 'x');

结果是：

"xxxxx"

这种写法在刷题中比较常用。

比如要构造一个长度为 n 的初始字符串：

string ans(n, '0');

---

二、string 的容量相关接口

容量相关接口是 string 中非常重要的一组。

常见函数有：

size()
length()
capacity()
empty()
clear()
reserve()
resize()

---

2.1 size 和 length

s.size()
s.length()

这两个函数都返回字符串中有效字符的个数。

例如：

string s = "hello";
cout << s.size() << endl;    // 5
cout << s.length() << endl;  // 5

从使用习惯上来说，C++ 容器普遍使用 size()。

所以日常更推荐使用：

s.size()

length() 更多是为了字符串语义保留的接口。

---

2.2 capacity

s.capacity()

返回的是当前 string 底层已经分配的容量。

注意：

size != capacity

size() 表示有效字符个数。

capacity() 表示当前底层空间最多能容纳多少有效字符。

比如：

string s = "hello";

size() 是 5。

capacity() 可能大于等于 5。

因为底层通常会预留一些空间，避免每次追加字符都重新申请内存。

---

2.3 empty

s.empty()

用于判断字符串是否为空。

if (s.empty())
{
    cout << "空字符串" << endl;
}

它等价于判断：

s.size() == 0

但语义更清晰。

---

2.4 clear

s.clear();

clear() 会清空字符串中的有效字符。

例如：

string s = "hello";
s.clear();

cout << s.size() << endl;  // 0

注意：

clear 通常不会改变底层容量。

也就是说，它只是让字符串逻辑上变空，不一定释放已经申请好的空间。

这样做是为了后续继续使用时减少重新分配的开销。

---

2.5 reserve

s.reserve(100);

reserve 的作用是预留容量。

它不会改变有效字符个数。

例如：

string s = "hello";
s.reserve(100);

cout << s.size() << endl;      // 5
cout << s.capacity() << endl;  // 至少能容纳 100 左右

它适合在你大致知道字符串会增长到多长时提前使用。

比如频繁拼接字符串：

string ret;
ret.reserve(10000);

for (...)
{
    ret += part;
}

这样可以减少扩容次数，提高效率。

---

2.6 resize

s.resize(n);
s.resize(n, ch);

resize 会改变有效字符个数。

如果 n 小于当前 size()，字符串会被截断。

如果 n 大于当前 size()，字符串会扩展。

扩展出来的位置：

resize(n)

通常用 '\0' 填充。

resize(n, ch)

用指定字符 ch 填充。

例如：

string s = "hello";
s.resize(8, 'x');

cout << s << endl;  // helloxxx

---

2.7 reserve 和 resize 的核心区别

这两个函数非常容易混。

reserve

只管容量，不改变有效字符个数。

resize

改变有效字符个数，必要时也可能改变容量。

例子：

string s = "hello";

s.reserve(100);
cout << s.size() << endl;  // 5

s.resize(100, 'x');
cout << s.size() << endl;  // 100

---

三、string 的访问和遍历

3.1 operator\[\]

最常用的访问方式是下标：

string s = "hello";

cout << s[0] << endl;  // h
s[0] = 'H';

operator[] 使用起来很方便，但要注意下标不能越界。

合法下标范围是：

0 ~ s.size() - 1

---

3.2 迭代器遍历

string 支持迭代器：

string s = "hello";

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

也可以用 auto 简化：

auto it = s.begin();
while (it != s.end())
{
    cout << *it << " ";
    ++it;
}

begin() 指向第一个字符。

end() 指向最后一个字符的下一个位置。

注意：

end() 不是最后一个字符，而是最后一个字符后面的位置。

---

3.3 反向迭代器

string 也支持反向遍历：

auto rit = s.rbegin();
while (rit != s.rend())
{
    cout << *rit << " ";
    ++rit;
}

这会从后往前访问字符串。

---

3.4 范围 for 遍历

最简单的遍历方式是范围 for：

for (auto ch : s)
{
    cout << ch << " ";
}

如果要修改字符，需要引用：

for (auto& ch : s)
{
    ch = toupper(ch);
}

这里一定要注意：

auto ch

是副本。

auto& ch

才是原字符引用。

---

四、string 的修改操作

4.1 push_back

push_back 用于在字符串尾部追加一个字符：

string s = "hello";
s.push_back('!');

cout << s << endl;  // hello!

---

4.2 append

append 用于追加字符串：

string s = "hello";
s.append(" world");

cout << s << endl;  // hello world

也可以追加若干个字符：

s.append(3, 'x');

---

4.3 operator+=

日常最常用的是 +=。

它既可以追加字符：

s += '!';

也可以追加字符串：

s += " world";

还可以追加另一个 string：

string t = " C++";
s += t;

一般情况下，尾部追加更推荐使用 +=。

写法自然，表达清楚。

---

4.4 operator+ 为什么要少用？

比如：

string s1 = "hello";
string s2 = "world";

string s3 = s1 + " " + s2;

这当然可以用。

但如果在循环中大量使用 + 拼接字符串，可能会产生较多临时对象。

例如：

string ret;

for (int i = 0; i < n; ++i)
{
    ret = ret + part;
}

这种写法可能效率较低。

更推荐：

string ret;
ret.reserve(预估长度);

for (int i = 0; i < n; ++i)
{
    ret += part;
}

核心思想是：

能预估长度时先 reserve，频繁拼接时优先 +=。

---

五、string 的查找和截取

5.1 find

find 用于从字符串中查找字符或子串。

string s = "hello world";

size_t pos = s.find("world");

如果找到了，返回第一次出现的位置。

如果没找到，返回：

string::npos

所以使用时一定要判断：

if (pos != string::npos)
{
    cout << "找到了" << endl;
}

不要直接拿 npos 当正常下标使用。

---

5.2 rfind

rfind 从后往前查找。

比如求最后一个单词长度时，经常会用：

size_t pos = line.rfind(' ');

如果字符串是：

"hello world"

最后一个空格的位置就是 5。

最后一个单词长度可以写成：

line.size() - pos - 1

不过实际写题时要注意没有空格的情况。

如果 rfind 返回 npos，说明整行就是一个单词。

---

5.3 substr

substr 用于截取子串。

string s = "hello world";

string sub = s.substr(6, 5);

结果是：

"world"

第一个参数表示起始位置。

第二个参数表示截取长度。

如果第二个参数省略，默认截取到字符串末尾：

string sub = s.substr(6);

---

5.4 c_str

c_str() 用于返回 C 风格字符串。

string s = "hello";
const char* p = s.c_str();

这个接口在和 C 库函数、某些系统接口交互时很有用。

但要注意：

返回的指针指向 string 内部数据。

当 string 被修改或销毁后，这个指针可能失效。

所以不要长期保存这个指针后继续使用。

---

六、输入输出：cin、getline 和空格问题

6.1 operator>>

可以直接输入字符串：

string s;
cin >> s;

但它有一个特点：

遇到空白字符就停止。

比如输入：

hello world

cin >> s 只能读到：

hello

---

6.2 getline

如果要读取一整行，应该使用：

getline(cin, line);

例如：

string line;
getline(cin, line);

它会读取一整行，包括中间的空格，直到换行结束。

所以处理整行文本、句子、带空格输入时，getline 更合适。

---

6.3 cin 和 getline 混用时的坑

如果前面用了：

cin >> n;

然后立刻：

getline(cin, line);

可能会读到一个空行。

原因是 cin >> n 读取数字后，换行符还留在输入缓冲区中。

getline 会把这个残留换行符当作一行结束。

常见处理方式是先消耗掉这个换行符：

cin.ignore();
getline(cin, line);

更严谨时可以写：

cin.ignore(numeric_limits<streamsize>::max(), '\n');

---

七、几个典型 OJ 字符串场景

7.1 仅反转字母

题意：

字符串中只有字母需要反转，其他字符位置不动。

思路：

用双指针。

左指针从前往后找字母。

右指针从后往前找字母。

找到后交换。

核心逻辑：

bool isLetter(char ch)
{
    return (ch >= 'a' && ch <= 'z')
        || (ch >= 'A' && ch <= 'Z');
}

string reverseOnlyLetters(string s)
{
    if (s.empty())
        return s;

    size_t left = 0;
    size_t right = s.size() - 1;

    while (left < right)
    {
        while (left < right && !isLetter(s[left]))
            ++left;

        while (left < right && !isLetter(s[right]))
            --right;

        swap(s[left], s[right]);
        ++left;
        --right;
    }

    return s;
}

这个题适合练习：

• string 下标访问
• 双指针
• 字符判断
• swap

---

7.2 找第一个只出现一次的字符

思路：

先统计每个字符出现次数。

再从前往后扫描字符串。

第一个出现次数为 1 的字符，就是答案。

int firstUniqChar(string s)
{
    int count[256] = {0};

    for (auto ch : s)
    {
        ++count[(unsigned char)ch];
    }

    for (int i = 0; i < s.size(); ++i)
    {
        if (count[(unsigned char)s[i]] == 1)
            return i;
    }

    return -1;
}

这个题适合练习：

• 计数数组
• 字符作为下标
• 按原字符串顺序查找答案

---

7.3 最后一个单词的长度

输入一整行，求最后一个单词长度。

不能用：

cin >> line;

因为它遇到空格就停止。

应该用：

getline(cin, line);

一种写法：

int LastWordLength(const string& line)
{
    size_t pos = line.rfind(' ');

    if (pos == string::npos)
        return line.size();

    return line.size() - pos - 1;
}

不过如果字符串末尾可能有空格，需要先处理尾部空格。

---

7.4 验证回文串

常见题意：

只考虑字母和数字，忽略大小写。

思路：

• 双指针
• 跳过非字母数字字符
• 比较时统一大小写

bool isLetterOrNumber(char ch)
{
    return (ch >= '0' && ch <= '9')
        || (ch >= 'a' && ch <= 'z')
        || (ch >= 'A' && ch <= 'Z');
}

char ToLower(char ch)
{
    if (ch >= 'A' && ch <= 'Z')
        return ch + 32;

    return ch;
}

bool isPalindrome(string s)
{
    int left = 0;
    int right = s.size() - 1;

    while (left < right)
    {
        while (left < right && !isLetterOrNumber(s[left]))
            ++left;

        while (left < right && !isLetterOrNumber(s[right]))
            --right;

        if (ToLower(s[left]) != ToLower(s[right]))
            return false;

        ++left;
        --right;
    }

    return true;
}

---

7.5 字符串相加

题意：

两个非负整数字符串相加，返回字符串形式的结果。

不能直接转成整数，因为数字可能非常大。

思路：

从后往前逐位相加，维护进位。

string addStrings(string num1, string num2)
{
    int i = num1.size() - 1;
    int j = num2.size() - 1;
    int carry = 0;
    string ret;

    while (i >= 0 || j >= 0 || carry)
    {
        int x = i >= 0 ? num1[i--] - '0' : 0;
        int y = j >= 0 ? num2[j--] - '0' : 0;

        int sum = x + y + carry;
        ret += char(sum % 10 + '0');
        carry = sum / 10;
    }

    reverse(ret.begin(), ret.end());
    return ret;
}

这个题很好地体现了 string 的使用价值：

• 下标访问
• 尾插字符
• reverse
• 字符和数字之间的转换

---

八、不同编译器下 string 的底层结构

8.1 string 不是简单的 char*

很多人刚开始会把 string 理解成：

char*

这不准确。

string 是一个类对象，内部通常会管理：

• 字符串数据
• 有效长度
• 当前容量
• 分配器或其他辅助信息

不同编译器和不同标准库实现，内部结构可能不同。

所以不要在代码中依赖某个实现细节。

---

8.2 小字符串优化

很多现代 string 实现会使用一种优化：

小字符串优化。

大致意思是：

当字符串比较短时，不一定去堆上申请空间，而是直接把字符存放在 string 对象内部的小缓冲区里。

这样可以减少小字符串频繁动态分配的成本。

比如很多名字、短单词、路径片段都比较短，直接存在对象内部效率更高。

当字符串超过内部缓冲区容量时，再转到堆上分配空间。

---

8.3 写时拷贝

早期某些实现中，string 可能使用写时拷贝。

写时拷贝的思想是：

拷贝时先共享资源，真正要修改时再拷贝一份。

它通常配合引用计数使用。

优点是减少不必要的拷贝。

缺点是实现复杂，在多线程和字符访问语义上会带来一些问题。

现代 C++ 标准库实现中，主流 string 已经不再把写时拷贝作为推荐实现方式。

入门阶段只需要了解：

写时拷贝是一种历史上出现过的优化思想，不是我们模拟实现 string 时的第一选择。

---

九、为什么要模拟实现 String？

标准库里的 string 很强大。

那为什么面试和学习中还要模拟实现？

因为模拟实现 String 能训练几个非常关键的 C++ 能力：

• 构造函数
• 析构函数
• 拷贝构造
• 赋值运算符重载
• 深拷贝
• 资源管理
• 自赋值处理
• 异常安全意识

这不是为了替代标准库 string。

而是为了理解：

一个管理动态资源的类，应该怎么写默认成员函数。

---

十、一个有问题的 String 类

先看一个简化版本：

class String
{
public:
    String(const char* str = "")
    {
        if (str == nullptr)
        {
            assert(false);
            return;
        }

        _str = new char[strlen(str) + 1];
        strcpy(_str, str);
    }

    ~String()
    {
        delete[] _str;
        _str = nullptr;
    }

private:
    char* _str;
};

构造函数申请空间。

析构函数释放空间。

看起来没问题。

但是如果写：

String s1("hello");
String s2(s1);

这里会调用编译器默认生成的拷贝构造函数。

默认拷贝构造会把 _str 的值直接复制给 s2._str。

也就是说：

s1._str == s2._str

两个对象指向同一块堆空间。

这就是浅拷贝。

---

十一、浅拷贝的问题

11.1 什么是浅拷贝？

浅拷贝也叫位拷贝。

意思是：

只把对象中的成员变量值原样复制一份。

如果成员变量是普通 int，没问题。

但如果成员变量是指针，就会把地址复制过去。

结果就是多个对象共享同一块资源。

---

11.2 浅拷贝为什么危险？

继续看：

String s1("hello");
String s2(s1);

浅拷贝后：

s1._str
s2._str

都指向同一块字符数组。

当程序结束时，两个对象都会析构：

delete[] s1._str;
delete[] s2._str;

同一块空间被释放两次，程序很可能崩溃。

此外，一个对象修改字符串内容，另一个对象也会受到影响。

所以对管理资源的类来说，浅拷贝通常是不够的。

---

十二、深拷贝解决问题

12.1 什么是深拷贝？

深拷贝的核心是：

每个对象都拥有自己独立的资源。

对于 String 来说，拷贝时不能只复制 _str 指针，而是要重新申请一块空间，再把字符串内容复制过去。

---

12.2 传统写法：拷贝构造

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

这样：

String s2(s1);

会让 s2 自己拥有一块新的空间。

内容和 s1 一样，但地址不同。

s1._str != s2._str

析构时各自释放自己的空间，不会重复释放。

---

12.3 传统写法：赋值运算符重载

赋值运算符用于两个已经存在的对象之间赋值。

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;
}

这里有几个细节：

第一，检查自赋值：

if (this != &s)

处理：

s1 = s1;

第二，先申请新空间，再释放旧空间。

这样如果申请失败，原对象还没有被破坏。

第三，返回 *this。

为了支持连续赋值：

s1 = s2 = s3;

---

十三、现代写法：拷贝交换

13.1 拷贝构造中的交换思想

可以写成：

String(const String& s)
    : _str(nullptr)
{
    String tmp(s._str);
    swap(_str, tmp._str);
}

这段代码的思路是：

先用 s._str 构造一个临时对象 tmp。

然后交换当前对象和 tmp 的资源。

tmp 析构时，会释放当前对象原来的资源。

这种写法简洁，并且复用了构造函数。

---

13.2 赋值运算符的现代写法

一种非常经典的写法是传值：

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

这里参数 s 是按值传参。

调用时会先生成一份拷贝。

然后当前对象和这份拷贝交换资源。

函数结束时，形参 s 析构，释放当前对象原来的旧资源。

这就是 copy-and-swap 思想。

它的优点是：

• 代码短
• 自赋值也能安全处理
• 异常安全性更好
• 复用拷贝构造和析构逻辑
  

---

十四、String 模拟实现的基本版本

#include <iostream>
#include <cstring>
#include <cassert>
using namespace std;

class String
{
public:
    String(const char* str = "")
    {
        if (str == nullptr)
        {
            assert(false);
            str = "";
        }

        _str = new char[strlen(str) + 1];
        strcpy(_str, str);
    }

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

    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;
    }

    ~String()
    {
        delete[] _str;
        _str = nullptr;
    }

    const char* c_str() const
    {
        return _str;
    }

private:
    char* _str;
};

这个版本不是为了替代标准库。

它的重点是展示：

只要类里管理动态资源，就必须认真处理拷贝构造、赋值运算符和析构函数。

---

十五、本文总结

这一篇主要围绕 string 的使用和模拟实现展开。

string 的容量接口中：

size() 和 length() 都表示有效字符个数。

capacity() 表示底层容量。

clear() 清空有效字符，但通常不释放容量。

reserve() 只预留空间，不改变有效长度。

resize() 会改变有效字符个数。

string 的访问方式包括：

• 下标访问
• 迭代器
• 反向迭代器
• 范围 for

string 的修改方式中：

• push_back 追加单个字符
• append 追加字符串
• += 更常用、更自然
• 大量拼接时少用 +，优先 reserve + +=

string 的查找和截取中：

• find 找不到返回 string::npos
• rfind 从后往前找
• substr 用于截取子串
• c_str 用于获得 C 风格字符串

输入时：

• cin >> s 遇到空格停止
• getline(cin, s) 读取整行

模拟实现 String 时：

• 默认拷贝会导致浅拷贝
• 浅拷贝会导致资源共享和重复释放
• 深拷贝让每个对象拥有独立资源
• 管理资源的类必须认真写拷贝构造、赋值运算符和析构函数

最后用一句话总结：

string 的接口是用来解决字符串问题的，而 string 的模拟实现是用来理解 C++ 资源管理本质的。

---