C++之STL整理（6）之string 用法（拼接、查找、替换、比较、截取子串）整理

C++之STL整理（6）之string 用法（拼接、查找、替换、比较、截取子串）整理

注：整理一些突然学到的C++知识，随时mark一下
例如：忘记的关键字用法，新关键字，新数据结构

---

---

提示：本文为 C++ 中 string替换、比较、子串的写法和举例

---

一、string的拼接

  C++ 中的 std::string 是一个非常强大的类，它提供了丰富的成员函数和操作符重载（关于string的基本操作），用于操作字符串。下面讲解其他的函数

1、字符串加法（拼接操作）

operator+=(const string& str);重载了加号+，两个string类的字符串可以直接相加：

string s = "Hello, ";  
s += "world!"; // s 现在为 "Hello, world!"

operator+=(const char* str);重载了加号+，可以与char*的字符串直接相加：

string s = "Hello, ";  
s += "world!"; // s 现在为 "Hello, world!"

operator+=(const char c);重载了加号+，可以与char的单个字符直接相加：

string s = "Hello";  
s += ','; // s 现在为 "Hello,"

2、append函数

append(...) 成员函数的行为与 operator+= 类似，只是名称不同。上述代码都可以转化为：

string s = "Hello";  
s.append(...);

二、字符串查找和替换

1、find

成员函数find(字符或字符串)返回的是所查找的子串或字符在主串中首次出现的那个位置的索引。如果未找到子串或字符，则find会返回std::string::npos，这是一个特殊的常量，用来表示未找到或超出范围的索引。
find(…)

string s = "Hello, world!";  
int pos = s.find("world"); // pos 为 7

2、rfind

rfind(…)意思是reverse的find
rfind成员函数返回的是所查找的子串或字符在主串中最后一次出现的位置的索引。如果未找到子串或字符，则rfind会返回std::string::npos，就像find函数一样。使用rfind时，它从字符串的末尾开始向前搜索，找到所查找的子串或字符最后一次出现的位置。

string s = "hello, hello, world";  
int pos = s.rfind("he"); // pos 为 7

3、替换

replace(...)成员函数不返回任何值（即返回类型为void），它直接修改调用它的字符串对象，将指定的子串或字符替换为另一个子串或字符。replace函数有多个重载版本，每个版本接受不同数量和类型的参数，以便以不同的方式执行替换操作。

以下是replace函数的一些常见重载版本及其参数的含义：

使用位置和计数进行替换

void replace(size_t pos1, size_t count, const string& str);  
void replace(size_t pos1, size_t count, const char* s);  
void replace(size_t pos1, size_t count, size_t count2, char c);
pos1：开始替换的位置的索引。
count：要替换的字符数。
str 或 s：用于替换的新字符串。
count2 和 c：用count2个字符c替换原字符串中的count个字符。

使用迭代器进行替换

void replace(iterator i1, iterator i2, const string& str);  
void replace(iterator i1, iterator i2, const char* s);  
void replace(iterator i1, iterator i2, size_t count, char c);
i1 和 i2：定义要替换的字符范围的迭代器。
str 或 s：用于替换的新字符串。
count 和 c：用count个字符c替换原字符串中由迭代器定义的范围内的字符。

使用子串进行替换

void replace(const_iterator i1, const_iterator i2, const string& str, size_t pos, size_t count);  
void replace(size_t pos1, size_t count1, const string& str, size_t pos, size_t count);
i1 和 i2 或 pos1 和 count1：定义要替换的字符范围。
str：源字符串，从中提取子串进行替换。
pos：在str中开始提取子串的位置。
count：从str中提取的字符数。

每个重载版本都允许你以不同的方式指定要替换的字符范围以及用于替换的内容。在调用replace函数时，你需要根据你的具体需求选择适当的重载版本，并提供正确的参数。请注意，replace函数直接修改调用它的字符串对象，而不返回任何新字符串。如果你需要保留原始字符串并创建一个包含替换结果的新字符串，你需要先复制原始字符串，然后对新字符串对象调用replace。

string s = "apple";  
s.replace(1, 3, "cherry"); 
// s 现在为 "acherrye"，可以理解为第一步删去起始位置开头的指定长度的部分
// 第二步把第一步删去的部分替换为cherry

三、比较与子串获取

1、字符串比较操作

compare函数用于比较两个字符串，使用compare函数时，如果返回值为0，则表示两个字符串相等；如果返回值小于0，则表示调用字符串字典序上小于比较字符串；如果返回值大于0，则表示调用字符串字典序上大于比较字符串。

compare函数有多个重载版本，允许你以不同的方式比较字符串。以下是compare函数的一些常见重载版本及其参数的含义：

比较整个字符串

int compare(const string& str) const noexcept;  
int compare(const char* s) const;

str 或 s：要与本字符串比较的字符串。
返回值：如果调用字符串小于、等于或大于比较字符串，则分别返回负整数-1、零或正整数1。

比较字符串的前n个字符

int compare(size_t pos1, size_t count1, const string& str) const;  
int compare(size_t pos1, size_t count1, const char* s) const;  
int compare(size_t pos1, size_t count1, const string& str, size_t pos2, size_t count2) const;  
int compare(size_t pos1, size_t count1, const char* s, size_t count2) const;

pos1 和 count1：定义调用字符串中用于比较的子串的起始位置和长度。
str 或 s：要与之比较的字符串。
pos2 和 count2（在相关重载中）：定义比较字符串中用于比较的子串的起始位置和长度。
返回值：与上述相同，根据字典序比较结果返回相应的整数值。
使用C风格的字符串和长度进行比较

int compare(size_t pos, size_t count, const char* s, size_t count2) const;

pos 和 count：定义调用字符串中用于比较的子串的起始位置和长度。
s 和 count2：定义C风格字符串中用于比较的子串的起始位置和长度。
返回值：与上述相同。

这里有一个简单的示例，展示了如何使用compare函数：

#include <iostream>  
#include <string>  
  
int main() {  
    std::string str1 = "apple";  
    std::string str2 = "banana";  
    std::string str3 = "apple";  
    const char* cstr = "apple";  
  
    // 比较整个字符串  
    int result1 = str1.compare(str2); // str1 < str2，返回负整数  
    int result2 = str1.compare(str3); // str1 == str3，返回0  
    int result3 = str1.compare(cstr); // str1 == cstr，返回0  
  
    // 比较字符串的前n个字符  
    int result4 = str2.compare(0, 4, str1); // 比较"bana"和"appl"，返回正整数  
    int result5 = str2.compare(0, 5, "apple"); // 比较"banan"和"apple"，返回正整数  
  
    // 输出比较结果  
    std::cout << "Result 1: " << result1 << std::endl;  
    std::cout << "Result 2: " << result2 << std::endl;  
    std::cout << "Result 3: " << result3 << std::endl;  
    std::cout << "Result 4: " << result4 << std::endl;  
    std::cout << "Result 5: " << result5 << std::endl;  
  
    return 0;  
}

在这个示例中，我们比较了不同字符串以及字符串的子串，并打印了比较结果。根据比较结果的正负或零，我们可以确定字符串之间的字典序关系。

2、字符串子串

substr(...)函数用于获取字符串的一个子串。这个函数返回一个新的std::string对象，该对象包含从原字符串的指定位置开始，具有指定长度的字符序列。

substr函数的原型如下：

std::string substr(size_t pos = 0, size_t count = npos) const;

pos：子串开始的位置索引。默认值为0，即从字符串的开始位置提取。
count：子串中字符的数量。默认值是std::string::npos，这是一个特殊的常量，表示从pos位置开始直到字符串的末尾。

以下是一些使用substr函数的例子：

#include <iostream>  
#include <string>  
  
int main() {  
    std::string str = "Hello, World!";  
      
    // 获取从索引0开始的5个字符的子串  
    std::string substr1 = str.substr(0, 5);  
    std::cout << "Substring 1: " << substr1 << std::endl; // 输出: Substring 1: Hello  
      
    // 获取从索引7开始到字符串末尾的子串  
    std::string substr2 = str.substr(7);  
    std::cout << "Substring 2: " << substr2 << std::endl; // 输出: Substring 2: World!  
      
    // 获取整个字符串（不指定pos和count）  
    std::string substr3 = str.substr();  
    std::cout << "Substring 3: " << substr3 << std::endl; // 输出: Substring 3: Hello, World!  
      
    return 0;  
}

在这个例子中，substr1是从字符串str的开始位置提取的5个字符的子串，即"Hello"。substr2是从字符串str的第7个字符开始直到末尾的子串，即"World!"。而substr3由于没有指定pos和count参数，因此提取了整个字符串。

需要注意的是，如果pos参数超出了原字符串的范围（即大于或等于字符串的长度），或者pos + count超出了原字符串的范围，substr函数将抛出std::out_of_range异常（如果使用了范围检查的迭代器）。

总结