C++中string库常用函数超详细解析与深度实践

共享家95272025-04-15 8:19

目录

一、引言

二、基础准备：头文件与命名空间

[三、string对象的创建与初始化(基础）](#三、string对象的创建与初始化(基础）)

[3.1 直接初始化](#3.1 直接初始化)

[3.2 动态初始化（空字符串）](#3.2 动态初始化（空字符串）)

[3.3 基于字符数组初始化](#3.3 基于字符数组初始化)

[3.4 重复字符初始化](#3.4 重复字符初始化)

四、核心函数详解

[4.1 字符串长度相关](#4.1 字符串长度相关)

[4.1.1 length() 和 size()](#4.1.1 length() 和 size())

[4.1.2 capacity() 和 reserve()](#4.1.2 capacity() 和 reserve())

[4.2 字符串拼接](#4.2 字符串拼接)

[4.2.1 + 运算符与 += 复合赋值](#4.2.1 + 运算符与 += 复合赋值)

[4.2.2 append() 函数（不咋好有，不推荐）](#4.2.2 append() 函数（不咋好有，不推荐）)

[4.3 字符串查找](#4.3 字符串查找)

[4.3.1 find() 系列函数](#4.3.1 find() 系列函数)

[4.4 子串提取](#4.4 子串提取)

[4.5 字符串替换](#4.5 字符串替换)

[4.5.1 replace() 函数](#4.5.1 replace() 函数)

[4.6 字符串比较](#4.6 字符串比较)

[4.6.1 compare() 函数](#4.6.1 compare() 函数)

[4.6.2 关系运算符（推荐）](#4.6.2 关系运算符（推荐）)

[4.7 字符串插入（少用，效率太底）](#4.7 字符串插入（少用，效率太底）)

[4.8 字符串删除（不推荐，理由如上）](#4.8 字符串删除（不推荐，理由如上）)

[4.9 字符串清空](#4.9 字符串清空)

[4.10 字符串遍历](#4.10 字符串遍历)

[4.10.1 迭代器遍历](#4.10.1 迭代器遍历)

[4.10.2 范围-based for循环](#4.10.2 范围-based for循环)

[4.11 getline() 函数](#4.11 getline() 函数)

[4.12 reverse() 函数](#4.12 reverse() 函数)

[4.13 at() 函数（参考operator[ ])](#4.13 at() 函数（参考operator[ ]))

[4.14 数值与字符串转换相关函数](#4.14 数值与字符串转换相关函数)

[4.14.1 to_string() 函数](#4.14.1 to_string() 函数)

[4.14.2 atoi() 函数](#4.14.2 atoi() 函数)

[4.14.3 itoa() 函数（非标准库函数）](#4.14.3 itoa() 函数（非标准库函数）)

[4.15 shrink_to_fit() 函数](#4.15 shrink_to_fit() 函数)

[4.16 assign() 函数(作用类似于覆盖)](#4.16 assign() 函数(作用类似于覆盖))

五、高级应用与性能优化

[5.1 stringstream 流处理](#5.1 stringstream 流处理)

[5.2 性能优化技巧](#5.2 性能优化技巧)

六、总结

一、引言

在C++编程体系中， string 类是处理文本数据的核心组件。相较于传统C风格以 \0 结尾的字符数组， string 类通过封装大量实用函数，不仅避免了手动内存管理的繁琐与安全隐患，还提供了丰富的操作方式，极大提升了字符串处理的便捷性和安全性。本文将对 string 库中常用函数进行深度剖析，结合大量代码示例与注意事项，帮助开发者全面掌握其使用技巧。

二、基础准备：头文件与命名空间

使用 string 类前，必须包含 <string> 头文件，并处理命名空间。常见方式有两种：

cpp

cpp 复制代码 
// 方式一：引入整个std命名空间

#include <string>

using namespace std;



// 方式二：显式指定std命名空间

#include <string>

std::string str;

注意：引入整个 std 命名空间可能引发命名冲突（如自定义函数名与 std 中函数名重复），推荐在小型项目或明确无冲突风险时使用；显式指定命名空间更安全，适合大型项目。

三、string对象的创建与初始化(基础）

3.1 直接初始化

cpp

cpp 复制代码 
// 字面量初始化

string str1 = "Hello, C++";

string str2("This is a string");



// 拷贝初始化

string str3 = str1;

3.2 动态初始化（空字符串）

cpp

cpp 复制代码 
string emptyStr; // 长度为0的字符串

3.3 基于字符数组初始化

cpp

cpp 复制代码 
char cArray[] = {'H', 'e', 'l', 'l', 'o', '\0'};

string strFromArray(cArray);

3.4 重复字符初始化

cpp

cpp 复制代码 
string repeated(5, 'a'); // 生成字符串 "aaaaa"

四、核心函数详解

4.1 字符串长度相关

4.1.1 length() 和 size()

cpp 复制代码 
cpp

string str = "Programming";

size_t len1 = str.length(); // 11

size_t len2 = str.size(); // 11

注意：

  • length() 和 size() 功能完全相同，++size() 是为了与STL容器接口统一。++

  • 返回值类型 size_t 是无符号整数，与负数比较时需格外小心，例如：

cpp 复制代码 
cpp

string str = "test";

if (str.length() > -1) { // 永远为真，-1会隐式转换为超大无符号数

    // ...

}

4.1.2 capacity() 和 reserve()

capacity() 返回当前字符串已分配的内存空间（以字符为单位）； reserve() 用于预分配内存，减少动态扩容次数。

cpp 复制代码 
cpp

string str;

cout << "初始容量: " << str.capacity() << endl; // 可能是15或其他默认值

str.reserve(100); // 预分配100个字符的空间

cout << "调整后容量: " << str.capacity() << endl; // 至少为100

注意： reserve() 不改变字符串实际长度，仅影响内存分配；若传入参数小于当前容量， reserve() 通常不执行操作。

4.2 字符串拼接

4.2.1 + 运算符与 += 复合赋值

cpp 复制代码 
cpp

string str1 = "Hello";

string str2 = "World";

string result = str1 + ", " + str2; // "Hello, World"

str1 += ", C++"; // 等价于 str1 = str1 + ", C++"

4.2.2 append() 函数（不咋好有，不推荐）

cpp 复制代码 
cpp

string str = "Apple";

// 追加字符串

str.append(" and Banana"); // "Apple and Banana"



// 追加子串（从源字符串第3个位置开始，取4个字符）

str.append("Cherry", 3, 4); // "Apple and Bananarry"



// 追加字符数组

char arr[] = {'!', '\0'};

str.append(arr); // "Apple and Bananarry!"

注意： append() 支持多种参数类型，使用时需确保索引和长度合法，避免越界。

4.3 字符串查找

4.3.1 find() 系列函数

cpp 复制代码 
cpp

string str = "banana";

// 查找子串首次出现位置

size_t pos1 = str.find("na"); // 2

// 查找字符最后出现位置

size_t pos2 = str.rfind('a'); // 5

// 查找字符集中任意字符首次出现位置

size_t pos3 = str.find_first_of("aeiou"); // 1

// 查找字符集中未出现的字符首次位置

size_t pos4 = str.find_first_not_of("abn"); // string::npos

注意：

  • 所有查找函数未找到时均返回 string::npos，建议使用 **if (pos != string::npos)**进行判断。

- find_first_of() 和 find_last_of() 匹配字符集中任意字符，而非整个集合。

4.4 子串提取

cpp 复制代码 
cpp

string str = "Hello, World";

// 提取从索引7开始，长度为5的子串

string sub = str.substr(7, 5); // "World"



// 若省略长度参数，提取到字符串末尾

string subAll = str.substr(7); // "World"

注意：起始索引不能超过字符串长度，否则行为未定义；长度参数过大时，会截取到字符串末尾。

4.5 字符串替换

4.5.1 replace() 函数

cpp 复制代码 
cpp

string str = "old text";

// 从索引4开始，替换4个字符

str.replace(4, 4, "new"); // "old new"



// 按子串替换（替换所有匹配项）

str = "apple apple";

str.replace(str.find("apple"), 5, "banana"); // "banana apple"

注意：若要替换所有匹配项，需循环调用 replace() ；替换操作可能改变字符串容量和迭代器状态。

4.6 字符串比较

4.6.1 compare() 函数

cpp 复制代码 
cpp

string str1 = "apple";

string str2 = "banana";

int cmp = str1.compare(str2); // cmp < 0

4.6.2 关系运算符（推荐）

cpp 复制代码 
cpp

if (str1 < str2) {

    cout << "str1小于str2" << endl;

}

注意：比较规则基于字典序（ASCII码顺序）； compare() 可指定子串进行局部比较，如 str1.compare(0, 3, str2, 0, 3) 。

4.7 字符串插入（少用，效率太底）

cpp 复制代码 
cpp

string str = "Hello";

// 在索引5处插入字符串

str.insert(5, ", World"); // "Hello, World"



// 插入多个重复字符

str.insert(0, 3, '*'); // "***Hello, World"

注意：插入操作会改变字符串长度和内存布局，可能导致迭代器失效；插入位置需在合法范围内。

4.8 字符串删除（不推荐，理由如上）

cpp 复制代码 
cpp

string str = "Hello, World";

// 删除从索引7开始的5个字符

str.erase(7, 5); // "Hello, "



// 删除单个字符（通过迭代器）

str.erase(str.begin() + 5); // "Hello"

注意：使用迭代器删除时，需确保迭代器有效；删除操作后，后续迭代器会失效。

4.9 字符串清空

cpp 复制代码 
cpp

string str = "data";

str.clear(); // 长度变为0，容量可能保留

注意： clear() 仅清空内容，不释放内存；若需释放内存，可使用 str.shrink_to_fit() 。

4.10 字符串遍历

4.10.1 迭代器遍历

cpp 复制代码 
cpp

string str = "abc";

for (string::iterator it = str.begin(); it != str.end(); ++it) {

    *it = toupper(*it); // 转换为大写

}

toupper为示例，以后会将。

4.10.2 范围-based for循环

cpp 复制代码 
cpp

string str = "123";

for (char c : str) {

    cout << c << endl;

}

注意：修改字符串内容时，需使用非 const 迭代器；范围循环中修改元素需通过引用（如 for (char& c : str) ）。

4.11 getline() 函数

getline() 函数是C++中用于从输入流中读取整行数据的重要工具，**它在处理包含空格或特殊字符的字符串输入时极为实用。(替换cin）**该函数定义于 <string> 头文件中，通过指定输入流对象和目标 string 对象，将输入流中的字符按行读取并存储。

函数原型：

cpp

cpp 复制代码 
istream& getline(istream& is, string& str, char delim = '\n');

其中， is 表示输入流（如 cin 用于从控制台读取）， str 是用于存储读取结果的 string 对象， delim 是可选参数，用于指定行结束的分隔符，默认值为换行符 \n 。

示例代码：

cpp 复制代码 
cpp
  
#include <iostream>
#include <string>
using namespace std;

int main() {
    string userInput;
    cout << "请输入一行包含空格的内容（例如：Hello, World!）: ";
    getline(cin, userInput);
    cout << "你输入的完整内容是: " << userInput << endl;

    // 指定其他分隔符的示例
    string data = "apple;banana;cherry";
    string token;
    size_t pos = 0;
    while ((pos = data.find(';')) != string::npos) {
        token = data.substr(0, pos);
        cout << "提取的子串: " << token << endl;
        data.erase(0, pos + 1);
    }
    if (!data.empty()) {
        cout << "最后一个子串: " << data << endl;
    }
    return 0;
}

运行结果：

cpp 复制代码 
plaintext
  
请输入一行包含空格的内容（例如：Hello, World!）: This is a test line.
你输入的完整内容是: This is a test line.
提取的子串: apple
提取的子串: banana
最后一个子串: cherry

注意事项：

  1. 输入流状态检查：当输入流发生错误（如磁盘读取错误）或到达文件末尾（EOF）时， getline() 会停止读取并使输入流进入错误状态。可以通过 if (cin) 或 cin.good() 检查输入流是否处于有效状态。

  2. 分隔符处理：若指定了非默认分隔符（如上述代码中的 ; ）， getline() 会读取字符直至遇到该分隔符。分隔符本身会被读取但不会存储到目标 string 中。

  3. 缓冲区残留问题：在使用 getline() 之前如果有其他输入操作（如 cin >> num 读取数字），可能会在输入缓冲区中残留换行符。此时可以先用 cin.ignore() 清除缓冲区残留字符，再调用 getline() ，避免读取到空字符串。

  4. 性能考量： getline() 每次读取都会动态分配内存来存储字符串，频繁调用可能影响性能。在处理大量数据时，可以预先使用 reserve() 为目标 string 分配足够的空间。

4.12 reverse() 函数

reverse() 函数用于反转字符串中字符的顺序，定义于 <algorithm> 头文件中，属于STL（标准模板库）算法的一部分。它通过操作迭代器范围来实现字符串反转，适用于需要快速颠倒字符串内容的场景。

函数原型：

cpp 复制代码 
cpp
  
template<class BidirectionalIterator>
void reverse(BidirectionalIterator first, BidirectionalIterator last);

其中， first 和 last 是双向迭代器，指定要反转的字符范围（左闭右开区间，即包含 first 指向的字符，不包含 last 指向的字符）。

示例代码：

cpp 复制代码 
cpp
  
#include <iostream>
#include <string>
#include <algorithm>
using namespace std;

int main() {
    string original = "C++ is powerful";
    cout << "原始字符串: " << original << endl;
    reverse(original.begin(), original.end());
    cout << "反转后的字符串: " << original << endl;

    // 反转子串示例
    string subStr = "hello, world";
    reverse(subStr.begin() + 7, subStr.end());
    cout << "反转部分子串后的结果: " << subStr << endl;
    return 0;
}

运行结果：

cpp 复制代码 
plaintext
  
原始字符串: C++ is powerful
反转后的字符串: lufrewop si ++C
反转部分子串后的结果: hello, dlrow

注意事项：

**1. 迭代器有效性：**传递给 reverse() 的迭代器必须指向有效的内存位置，且 last 迭代器需在 first 迭代器之后（指向更大的地址），否则会导致未定义行为。

  1. 对其他容器的适用性： reverse() 不仅适用于 string ，还可用于其他支持双向迭代器的容器（如 vector<char> ），但需确保容器类型兼容。

  2. 性能与内存： reverse() 操作通常效率较高，因为它仅改变字符顺序，不涉及额外的内存分配。但对于大型字符串，操作过程中可能会占用一定的栈空间。

4.13 at() 函数（参考operator[ ])

at() 函数是 string 类提供的成员函数，用于访问字符串中指定位置的字符。与通过 [] 运算符访问字符不同， at() 函数会进行严格的越界检查，若访问位置超出字符串长度，会抛出 std::out_of_range 异常。

函数原型：

cpp 复制代码 
cpp
  
char& at(size_t pos);
const char& at(size_t pos) const;

其中， pos 是要访问的字符的索引位置（从0开始）。非 const 版本返回可修改的字符引用， const 版本用于常量字符串，返回常量字符引用。

示例代码：

cpp 复制代码 
cpp
  
#include <iostream>
#include <string>
#include <exception>
using namespace std;

int main() {
    string text = "example";
    try {
        char normalChar = text.at(3);
        cout << "正常访问索引3处的字符: " << normalChar << endl;

        char badChar = text.at(10);  // 触发越界异常
    } catch (const out_of_range& e) {
        cerr << "捕获到异常: " << e.what() << endl;
    }

    // 与[]运算符对比
    try {
        char safeChar = text[3];
        char riskyChar = text[10];  // 不会抛出异常，但结果未定义
        cout << "使用[]访问越界位置未触发异常，结果不可靠" << endl;
    } catch (...) {
        cerr << "使用[]访问未触发异常捕获" << endl;
    }
    return 0;
}

运行结果：

plaintext

正常访问索引3处的字符: a
捕获到异常: basic_string::at: __n (which is 10) >= this->size() (which is 7)

使用[]访问越界位置未触发异常，结果不可靠

注意事项：

  1. 异常处理成本： at() 的越界检查和异常抛出机制增加了代码的安全性，但也带来了性能开销。在已知索引合法的场景下（如遍历字符串），使用 [] 运算符可能更高效。

  2. 字符修改：通过 at() 返回的引用可以修改字符串中的字符，但需确保字符串本身是非 const 类型。

  3. 索引类型： at() 的参数类型为 size_t （无符号整数），传入负数会导致编译错误或未定义行为。

4.14 数值与字符串转换相关函数

4.14.1 to_string() 函数

to_string() 函数是C++11引入的标准库函数，用于将基本数值类（如 int 、 double 、 long 等）转换为对应的字符串表示。它极大简化了数值与文本之间的转换过程。

函数原型：

cpp 复制代码 
cpp
  
string to_string(int val);
string to_string(long val);
string to_string(long long val);
string to_string(unsigned val);
string to_string(unsigned long val);
string to_string(unsigned long long val);
string to_string(float val);
string to_string(double val);
string to_string(long double val);

每个重载版本对应不同的数值类型，返回值为转换后的字符串。

示例代码：

cpp 复制代码 
cpp
  
#include <iostream>
#include <string>
using namespace std;

int main() {
    int numInt = 123;
    double numDouble = 3.14159;
    string strInt = to_string(numInt);
    string strDouble = to_string(numDouble);
    cout << "整数 " << numInt << " 转换为字符串: " << strInt << endl;
    cout << "浮点数 " << numDouble << " 转换为字符串: " << strDouble << endl;

    // 拼接字符串示例
    string result = "The value is " + to_string(numDouble) + " and the count is " + to_string(numInt);
    cout << result << endl;
    return 0;
}

运行结果：

cpp 复制代码 
plaintext
  
整数 123 转换为字符串: 123
浮点数 3.14159 转换为字符串: 3.141590
The value is 3.141590 and the count is 123

注意事项：

  1. 精度控制：对于浮点数转换， to_string() 默认保留6位小数。如需自定义精度，可使用 stringstream 或 std::format （C++20）等工具。

  2. 性能优化：虽然 to_string() 方便易用，但频繁调用可能产生大量临时字符串对象。在性能敏感场景下，可预先计算字符串长度并使用 std::snprintf 等C风格函数手动构建字符串。

4.14.2 atoi() 函数

atoi() （ ASCII to Integer ）函数用于将字符串转换为整数，其功能仅限于处理以数字开头的字符串，并在遇到非数字字符时停止转换。该函数定义于 <cstdlib> 头文件中，同时还有 **atol() （转换为 long ）、 atoll() （转换为 long long ）**等变体。

函数原型：

cpp 复制代码 
cpp
  
int atoi(const char* str);

参数 str 是指向以 \0 结尾的字符数组的指针，返回值为转换后的整数。若字符串无法转换（如开头非数字），返回0。

示例代码：

cpp 复制代码 
cpp
  
#include <iostream>
#include <string>
#include <cstdlib>
using namespace std;

int main() {
    string numStr = "42abc";
    int result = atoi(numStr.c_str());
    cout << "字符串 \"" << numStr << "\" 转换为整数: " << result << endl;

    string badStr = "abc123";
    int badResult = atoi(badStr.c_str());
    cout << "无法转换的字符串 \"" << badStr << "\" 结果: " << badResult << endl;
    return 0;
}

运行结果：

cpp 复制代码 
plaintext
  
字符串 "42abc" 转换为整数: 42
无法转换的字符串 "abc123" 结果: 0

注意事项：

  1. 参数类型转换：由于 atoi() 接受 const char* 类型参数，使用 string 对象时需调用 c_str() 方法进行转换。

  2. 错误处理： atoi() 无法区分输入错误（如非数字开头）和有效输入（如字符串 "0" ），需要额外逻辑判断输入合法性。

  3. 溢出风险：若转换结果超出 int 类型的表示范围（如 2147483647 以上的正数）， atoi() 的行为未定义。建议使用 std::stoi 等更安全的C++风格转换函数替代。

4.14.3 itoa() 函数（非标准库函数）

itoa() （ Integer to ASCII ）函数用于将整数转换为字符串，但其并非C++标准库的一部分，不同编译器和平台的实现存在差异。例如，在Windows平台的Visual C++中可直接使用，而在Linux的GCC中需通过 sprintf(C)****或 std::stringstream等方式替代。

Windows平台示例代码：

cpp 复制代码 
cpp
  
#include <iostream>
#include <string>
#include <stdlib.h>  // 包含itoa定义（Windows特定）
using namespace std;

int main() {
    int number = -123;
    char buffer[20];
    itoa(number, buffer, 10);  // 第二个参数是目标字符数组，第三个参数是进制数（10表示十进制）
    string result(buffer);
    cout << "整数 " << number << " 转换为字符串: " << result << endl;
    return 0;
}

运行结果：

cpp 复制代码 
plaintext
  
整数 -123 转换为字符串: -123

替代方案（GCC/Linux）：

cpp 复制代码 
cpp
  
#include <iostream>
#include <string>
#include <sstream>
using namespace std;

string customItoa(int num) {
    stringstream ss;
    ss << num;
    return ss.str();
}

int main() {
    int number = 456;
    string result = customItoa(number);
    cout << "整数 " << number << " 转换为字符串: " << result << endl;
    return 0;
}

注意事项：

  1. 可移植性问题：由于 itoa() 不属于标准库，使用该函数会导致代码在不同平台间无法直接移植。为确保兼容性，推荐使用 to_string() 或 stringstream 等标准方法。

  2. 缓冲区管理：在使用 itoa() 时，需手动指定目标字符数组的大小，若数组空间不足，可能导致缓冲区溢出。

  3. 功能局限性： itoa() 仅支持有限的进制转换（如2、8、10、16），而 stringstream 等方式可更灵活地控制输出格式。

4.15 shrink_to_fit() 函数

shrink_to_fit() 函数是 string 类的成员函数，用于释放字符串中未使用的额外内存，将字符串的容量**（ capacity ）调整为当前实际使用的大小（ size ）**。在对字符串进行了多次插入、删除操作后，字符串的容量可能会大于实际存储字符所需的空间(空间对齐）， shrink_to_fit() 函数可以帮助优化内存使用。（如果数据没有clear，则shrink_to_fit不会删除空间)

函数原型：

cpp 复制代码 
cpp
  
void shrink_to_fit();

该函数没有参数，也没有返回值，直接对调用它的 string 对象进行内存调整操作。

示例代码：

cpp 复制代码 
cpp
  
#include <iostream>
#include <string>
using namespace std;

int main() {
    string str = "initial string";
    cout << "初始容量: " << str.capacity() << endl;
    cout << "初始大小: " << str.size() << endl;

    // 进行一些操作，可能导致容量增加
    for (int i = 0; i < 100; ++i) {
        str += 'a';
    }
    cout << "操作后的容量: " << str.capacity() << endl;
    cout << "操作后的大小: " << str.size() << endl;

    str.shrink_to_fit();
    cout << "调用shrink_to_fit后的容量: " << str.capacity() << endl;
    cout << "调用shrink_to_fit后的大小: " << str.size() << endl;

    return 0;
}

运行结果（示例，实际结果可能因编译器和平台不同而有所差异）：

cpp 复制代码 
plaintext
  
初始容量: 31
初始大小: 14
操作后的容量: 127
操作后的大小: 114
调用shrink_to_fit后的容量: 114
调用shrink_to_fit后的大小: 114

注意事项：

  1. 并非保证完全释放内存：虽然 shrink_to_fit() 的目的是释放未使用的内存，但具体的实现可能会因为编译器和标准库的不同而有所差异，有些情况下可能无法将容量精确地调整为大小，或者可能会保留一些额外的内存空间。

  2. 可能导致迭代器失效：调用 shrink_to_fit() 函数会改变字符串的内存布局，因此在调用该函数之前获取的所有迭代器、引用和指针都将失效，使用它们会导致未定义行为。

  3. 性能影响：执行 shrink_to_fit() 操作可能涉及重新分配内存和复制数据，对于大型字符串，这可能会带来一定的性能开销，因此在性能敏感的场景中，需要谨慎使用。

4.16 assign() 函数(作用类似于覆盖)

assign() 函数是 string 类的成员函数，用于将一个新的字符串值赋给当前 string 对象，它提供了多种重载形式，可以以不同的方式指定要赋值的内容。

函数原型及示例：

  1. 赋值字符串字面量：
cpp 复制代码 
cpp
  
string& assign(const char* s);
cpp 复制代码 
cpp
  
#include <iostream>
#include <string>
using namespace std;

int main() {
    string str;
    str.assign("new string value");
    cout << "赋值后的字符串: " << str << endl;
    return 0;
}

运行结果：

cpp 复制代码 
plaintext
  
赋值后的字符串: new string value
  1. 赋值另一个 string 对象：
cpp 复制代码 
cpp
  
string& assign(const string& s);
 
 
cpp
  
#include <iostream>
#include <string>
using namespace std;

int main() {
    string str1 = "original";
    string str2;
    str2.assign(str1);
    cout << "str2赋值后的内容: " << str2 << endl;
    return 0;
}

运行结果：

cpp 复制代码 
plaintext
  
str2赋值后的内容: original
  1. 赋值字符串的子串：
cpp 复制代码 
cpp
  
string& assign(const char* s, size_t n);

其中 s 是字符指针， n 是要复制的字符个数。

cpp 复制代码 
cpp
  
#include <iostream>
#include <string>
using namespace std;

int main() {
    string str;
    const char* source = "abcdefg";
    str.assign(source, 3);
    cout << "赋值子串后的字符串: " << str << endl;
    return 0;
}

运行结果：

cpp 复制代码 
plaintext
  
赋值子串后的字符串: abc
  1. 重复赋值字符：
cpp 复制代码 
cpp
  
string& assign(size_t n, char c);

其中 n 是重复的次数， c 是要重复的字符。

cpp 复制代码 
cpp
  
#include <iostream>
#include <string>
using namespace std;

int main() {
    string str;
    str.assign(5, '*');
    cout << "重复赋值字符后的字符串: " << str << endl;
    return 0;
}

运行结果：

cpp 复制代码 
plaintext
  
重复赋值字符后的字符串: *****

注意事项：

  1. 覆盖原有内容： assign() 函数会完全覆盖当前 string 对象的原有内容，因此在调用该函数之前需要确保不再需要原有的字符串数据。

  2. 内存管理：根据赋值的内容不同， assign() 可能会重新分配内存来存储新的字符串。如果新字符串比原字符串大，会进行内存扩容；如果新字符串比原字符串小，可能会导致内存释放或保留（取决于具体实现）。

  3. 迭代器和引用失效：由于 assign() 会改变字符串的内容和长度，可能会导致之前获取的迭代器、引用和指针失效，使用它们会导致未定义行为。在调用 assign() 之后，如果需要使用迭代器等，应该重新获取。

五、高级应用与性能优化

5.1 stringstream 流处理

stringstream用于字符串与其他数据类型的转换，例如：

cpp 复制代码 
cpp

#include <sstream>

string numStr = "123";

int num;

stringstream ss(numStr);

ss >> num; // num = 123

5.2 性能优化技巧

  • 预分配内存：使用 reserve() 减少动态扩容次数。

  • 避免频繁拷贝：优先使用 **std::move()**转移字符串所有权，减少深拷贝开销。

  • 临时对象复用：避免在循环中创建大量临时 string 对象。

六、总结

C++ string 库的函数体系覆盖了字符串处理的全生命周期，从基础创建、拼接、查找，到复杂的替换、性能优化，每个函数都有其独特的应用场景。开发者在使用时需注意边界条件、内存管理和迭代器有效性等问题，结合实际需求灵活运用，才能发挥 string 类的最大效能。通过不断实践和总结，能够更高效地处理文本数据，提升C++程序的稳定性与性能。

相关推荐
珊瑚里的鱼4 分钟前
【双指针】专题：LeetCode 202题解——快乐数
开发语言·c++·笔记·算法·leetcode·职场和发展
2401_8582861143 分钟前
CD27.【C++ Dev】类和对象(18)友元和内部类
开发语言·c++·类和对象
（王子变青蛙）1 小时前
C++初始
开发语言·c++·程序人生
莫有杯子的龙潭峡谷1 小时前
4.15 代码随想录第四十四天打卡
c++·算法
灋✘逞_兇1 小时前
快速幂+公共父节点
数据结构·c++·算法·leetcode
姜行运2 小时前
每日算法(双指针算法)（Day 1)
c++·算法·c#
十五年专注C++开发2 小时前
面试题：请描述一下你在项目中是如何进行性能优化的？针对哪些方面进行了优化，采取了哪些具体的措施？
开发语言·数据结构·c++·qt·设计模式·性能优化
爱奥尼欧2 小时前
C++基础语法（1）
c语言·c++
pixel32 小时前
C++ STL常见容器
c++
wuqingshun3141592 小时前
经典算法 判断一个图是不是树
数据结构·c++·算法·蓝桥杯·深度优先
热门推荐
01我决定放弃搞 Java 了02RAG 实践- Ollama+RagFlow 部署本地知识库03DeepSeek各版本说明与优缺点分析04Scipy||第三章 线性代数 (scipy.linalg)05DeepSeek RAGFlow构建本地知识库系统06如何在WPS和Word/Excel中直接使用DeepSeek功能07C#/.NET/.NET Core技术前沿周刊 | 第 34 期（2025年4.7-4.13）08汽车上的各种质量：整备质量、总质量、装载质量、簧上质量、簧下质量09本地化部署AI知识库：基于Ollama+DeepSeek+AnythingLLM保姆级教程10ZNS SSD垃圾回收优化方案解读-1