引言

C 风格字符串(字符数组)虽然简单,但容易引发缓冲区溢出、忘记空字符等问题。C++ 标准库提供了 std::string 类(位于 <string> 头文件),它封装了字符数组,自动管理内存,并提供了丰富的成员函数,让字符串操作变得安全、便捷。std::string 是 C++ 中处理文本的首选方式。本文将详细介绍 std::string 的多种构造方法、拼接(+、+=、append)、查找(find、rfind)、替换(replace)和提取子串(substr),并通过内存模型解释其内部存储机制。


1. std::string 的构造

std::string 提供了多种构造函数,方便从不同来源创建字符串。

#include <iostream>
#include <string>

int main() {
    // 默认构造:空字符串
    std::string s1;

    // 从 C 风格字符串构造
    std::string s2 = "Hello";

    // 拷贝构造
    std::string s3(s2);

    // 从字符重复构造:生成 5 个 'A'
    std::string s4(5, 'A');   // "AAAAA"

    // 从子串构造(从位置 1 开始,取 3 个字符)
    std::string s5(s2, 1, 3); // "ell"

    // C++11 支持原始字符串字面量(忽略转义)
    std::string s6(R"(C:\Program Files\test)");

    // 使用初始化列表
    std::string s7 = {'C', '+', '+'};

    std::cout << "s2: " << s2 << std::endl;
    std::cout << "s4: " << s4 << std::endl;
    std::cout << "s5: " << s5 << std::endl;
    std::cout << "s7: " << s7 << std::endl;

    return 0;
}

2. 字符串拼接

std::string 支持使用 + 和 += 运算符,以及 append 成员函数进行拼接。

#include <iostream>
#include <string>

int main() {
    std::string hello = "Hello";
    std::string world = "World";

    // 使用 + 拼接(生成新字符串)
    std::string s1 = hello + " " + world;   // "Hello World"

    // 使用 += 追加
    std::string s2 = "Hello";
    s2 += " ";
    s2 += world;   // s2 变为 "Hello World"

    // 使用 append 追加(支持多种重载)
    std::string s3 = "Hello";
    s3.append(" ").append(world);   // 链式调用
    s3.append(3, '!');              // 追加 3 个 '!' -> "Hello World!!!"

    // 追加子串
    std::string s4 = "Hello";
    s4.append(world, 2, 3);         // 从 world[2] 开始取 3 个字符:"rld"
    std::cout << s4 << std::endl;    // "Hellorld"

    return 0;
}

3. 查找子串与字符

find 系列函数用于查找子串或字符的位置,返回下标(size_t 类型),若未找到则返回 std::string::npos。

#include <iostream>
#include <string>

int main() {
    std::string str = "Hello, C++ world! Welcome to C++.";

    // 正向查找第一个匹配的子串
    size_t pos1 = str.find("C++");
    if (pos1 != std::string::npos) {
        std::cout << "找到 C++ 在位置 " << pos1 << std::endl;  // 输出 7
    }

    // 从指定位置开始查找
    size_t pos2 = str.find("C++", pos1 + 1);  // 从上一个结果之后查找
    if (pos2 != std::string::npos) {
        std::cout << "再次找到 C++ 在位置 " << pos2 << std::endl; // 输出 30
    }

    // 反向查找(从右向左)
    size_t rpos = str.rfind("C++");
    std::cout << "最后一次出现位置: " << rpos << std::endl; // 30

    // 查找单个字符
    size_t comma = str.find(',');
    std::cout << "逗号位置: " << comma << std::endl; // 5

    // 查找第一次出现的任意字符(集合)
    size_t punct = str.find_first_of(",!");   // 找逗号或感叹号
    std::cout << "第一个标点位置: " << punct << std::endl; // 5

    // 查找第一个不在集合中的字符
    size_t alpha = str.find_first_not_of("Helo, "); // 跳过 H e l o 逗号 空格
    std::cout << "第一个非这些字符的位置: " << alpha << std::endl;

    return 0;
}

注意:npos 是一个静态常量,通常值为 -1 转换为 size_t(即最大值)。


4. 替换字符串中的内容

replace 函数用于替换字符串中的一段子串。

#include <iostream>
#include <string>

int main() {
    std::string str = "I like C++";

    // 替换从位置 7 开始的 3 个字符为 "Python"
    str.replace(7, 3, "Python");
    std::cout << str << std::endl;  // "I like Python"

    // 更复杂的替换:用另一字符串的一部分替换
    std::string src = "Java and C#";
    str.replace(7, 6, src, 0, 4);   // 用 src 的 [0,4) 即 "Java" 替换
    std::cout << str << std::endl;  // "I like Java"

    // 使用迭代器范围替换
    str = "Hello world";
    auto it = str.begin() + 6;
    str.replace(it, it + 5, "C++");
    std::cout << str << std::endl;  // "Hello C++"

    return 0;
}

5. 提取子串 substr

substr(pos, count) 返回从 pos 开始,长度为 count 的子串。如果 count 省略或超过字符串长度,则提取到末尾。

#include <iostream>
#include <string>

int main() {
    std::string str = "Hello, C++ world";

    // 提取从下标 7 开始的 3 个字符
    std::string sub1 = str.substr(7, 3);   // "C++"
    std::cout << sub1 << std::endl;

    // 提取从下标 7 到末尾
    std::string sub2 = str.substr(7);      // "C++ world"
    std::cout << sub2 << std::endl;

    // 提取整个字符串的副本
    std::string copy = str.substr(0);
    std::cout << copy << std::endl;

    // 注意:如果 pos 超出字符串长度,会抛出 std::out_of_range 异常
    try {
        std::string bad = str.substr(100);
    } catch (const std::out_of_range& e) {
        std::cout << "异常: " << e.what() << std::endl;
    }

    return 0;
}

6. 内存模型讲解

std::string 内部通常包含三个成员:指向字符数组的指针、字符串长度、容量。具体实现因标准库而异(常见为小字符串优化 SSO)。

6.1 小字符串优化 (SSO)

对于很短的字符串(如长度小于 15 或 22 字节),std::string 会直接存储在对象内部(栈上),避免动态内存分配。对于长字符串,则在堆上分配内存。

std::string s1 = "short";    // 可能使用 SSO,无堆分配
std::string s2 = "a very long string that exceeds the SSO buffer size"; // 堆分配

6.2 动态内存增长

当拼接导致长度超过当前容量时,std::string 会重新分配更大的内存(通常翻倍或按一定比例增长),复制旧内容到新内存,然后释放旧内存。这类似于 std::vector。

std::string s = "Hello";
const char* old_ptr = s.c_str();
s += " world, this is a long string";
// 此时旧内存可能已释放,s.c_str() 返回新地址

6.3 内存布局示意

假设一个典型的实现(无 SSO):

std::string 对象 (栈上):
+---------------+
| char* data    | ---> 堆上的字符数组 (如 "Hello\0")
| size_t len    | = 5
| size_t cap    | = 15 (例如)
+---------------+

修改字符串(如 append)会调整 len,若 len+新长度 > cap 则重新分配。

6.4 字符串数据以 '\0' 结尾

为了兼容 C 风格字符串,std::string 内部保证在末尾有一个空字符,可通过 c_str() 获取 C 风格指针。但 std::string 允许存储包含 '\0' 的字符串(长度独立于空字符),只是 c_str() 返回的指针在第一个 '\0' 处截断?实际上标准规定 c_str() 返回的数组包含 '\0',且若字符串中间有 '\0',c_str() 仍会包含它们,但长度由 size() 决定。不过为了安全,避免在 std::string 中嵌入 '\0' 除非必要。


7. 常见错误与避坑

错误说明正确做法
使用 find 未检查 npos直接使用返回值可能导致越界if (pos != std::string::npos)
误以为 substr 修改原字符串substr 返回新字符串,原串不变需要修改则用 replace 或赋值
频繁拼接导致多次重分配大量 += 可能效率低使用 reserve 预分配空间
将 std::string 传给 C 函数时忘记 c_str()直接传递 str 会编译错误使用 str.c_str()
混淆 size() 和 length()两者相同,但习惯用 size()无区别

8. 练习题

题目:编写一个 C++ 程序,完成以下任务:

  1. 创建一个 std::string 变量 text,初始化为 "C++ programming is fun"。
  2. 查找单词 "fun" 的位置,并将其替换为 "awesome",输出替换后的字符串。
  3. 提取子串:从字符串中提取 "programming" 并输出。
  4. 在字符串末尾拼接 " and powerful"。
  5. 查找第一个空格的位置,并输出该位置。
  6. 使用 find_first_of 查找第一个元音字母(a, e, i, o, u)的位置,输出该字符。
  7. 演示 reserve 预分配:创建一个空字符串,使用 reserve(100) 预分配,然后循环拼接 50 个字符,观察内存重新分配次数(可选:通过 capacity 变化)。

期望输出(示例):

替换后: C++ programming is awesome
提取的子串: programming
拼接后: C++ programming is awesome and powerful
第一个空格位置: 3
第一个元音位置: 1, 字符 '+'(? 注意:C++ 中 '+' 不是元音,实际应找到 'o' 或类似,根据内容)

上期参考答案

#include <iostream>
#include <cstring>

// 手动实现 strlen
size_t my_strlen(const char* s) {
    size_t len = 0;
    while (s[len] != '\0') {
        ++len;
    }
    return len;
}

int main() {
    // 1. 定义并初始化
    char str1[20] = "Hello";   // 留足空间
    char str2[] = "World";

    // 2. strlen
    std::cout << "str1 长度: " << strlen(str1) << ", str2 长度: " << strlen(str2) << std::endl;

    // 3. strcpy
    strcpy(str1, str2);
    std::cout << "复制后 str1: " << str1 << std::endl;

    // 4. strcat
    char buffer[30] = "Hello ";
    strcat(buffer, "C++");
    std::cout << "拼接结果: " << buffer << std::endl;

    // 5. strcmp
    const char* a = "apple";
    const char* b = "banana";
    int cmp = strcmp(a, b);
    if (cmp < 0) {
        std::cout << a << " 与 " << b << " 比较: " << a << " 小于 " << b << std::endl;
    } else if (cmp > 0) {
        std::cout << a << " 大于 " << b << std::endl;
    } else {
        std::cout << a << " 等于 " << b << std::endl;
    }

    // 6. 手动实现
    const char* test = "Hello";
    std::cout << "手动实现 strlen(\"Hello\"): " << my_strlen(test) << std::endl;

    return 0;
}

总结:std::string 是 C++ 中处理字符串的现代化工具,它自动管理内存,提供了丰富的成员函数:构造、拼接(+、append)、查找(find、rfind、find_first_of)、替换(replace)和子串(substr)。理解其内存模型(SSO、动态增长)有助于写出高效的代码。通过练习题,你应能熟练运用这些操作。下一篇文章我们将学习结构体(struct),进入自定义数据类型的领域。

Logo

AtomGit 是由开放原子开源基金会联合 CSDN 等生态伙伴共同推出的新一代开源与人工智能协作平台。平台坚持“开放、中立、公益”的理念,把代码托管、模型共享、数据集托管、智能体开发体验和算力服务整合在一起,为开发者提供从开发、训练到部署的一站式体验。

更多推荐