std::string类常用操作

std::string 是 C++ 标准库中的一个类，用于表示和操作字符串。使用 std::string 类可以方便地进行字符串的创建、修改、连接、查找等操作，而且相较于传统的 C 语言风格的字符串操作，std::string 提供了更多的便利和安全性。

string赋值操作

用于将一个字符串赋值给另一个字符串对象，包括使用=进行赋值和使用assign()函数进行赋值。

1. string赋值操作=:

std::string str1 = "Hello";  // 使用字符串字面值初始化
std::string str2;
str2 = str1;  // 使用赋值操作符将str1的值赋给str2

2. 使用assign()函数:

std::string str1 = "Hello";  // 使用字符串字面值初始化
std::string str2;
str2.assign(str1);  // 使用assign()函数将str1的值赋给str2

3. 使用另一个字符串进行赋值：

std::string str1 = "Hello";  // 使用字符串字面值初始化
std::string str2 = str1;  // 使用另一个字符串进行赋值

4. 使用C风格字符串进行赋值：

const char* cstr = "Hello";  // C风格字符串
std::string str;
str = cstr;  // 使用C风格字符串进行赋值

string访问字符

可以通过下标运算符[]访问字符串中的单个字符，也可以使用at()函数进行访问。还可以使用front()和back()函数分别获取字符串的第一个字符和最后一个字符。

1. 使用下标运算符[ ]：

std::string str = "Hello";
char ch = str[0];  // 访问第一个字符 'H'

2. 使用at( )函数：

std::string str = "Hello";
char ch = str.at(1);  // 访问第二个字符 'e'

3. 使用front( )函数和back( )函数：

std::string str = "Hello";
char firstChar = str.front();  // 获取第一个字符 'H'
char lastChar = str.back();    // 获取最后一个字符 'o'

string拼接操作

使用加号运算符+可以将多个字符串拼接在一起，单个字符串无法拼接，字符串对象才能拼接

1. 使用加号运算符 +：

std::string str1 = "Hello";
std::string str2 = "World";
std::string result = str1 + str2;  // 拼接str1和str2得到"HelloWorld"

2. 使用+=运算符进行原地拼接：

std::string str1 = "Hello";
std::string str2 = "World";
str1 += str2;  // 原地拼接，str1变为"HelloWorld"

3. 将其他类型的数据拼接到字符串中：

std::string str = "The value is: ";
int value = 42;
str += std::to_string(value);  // 拼接整数，结果为"The value is: 42"

//to_string:将数字常量转换为字符串，返回值为转换完毕的字符串

string插入操作

可以使用insert()函数在指定位置插入字符或子字符串。

1. 在指定位置插入字符串：

std::string str = "Hello";
std::string insertStr = " World";
str.insert(5, insertStr);  // 在位置5插入" World"，结果为"Hello World"

2. 在字符串末尾插入字符串：

std::string str = "Hello";
std::string insertStr = " World";
str.insert(str.length(), insertStr);  // 在末尾插入" World"，结果为"Hello World"
//insert()函数的第一个参数是要插入的位置，可以用str.length()来表示字符串的末尾位置。

string 删除操作

使用erase()函数可以删除字符串中的字符或子字符串。

1. 删除单个字符：

std::string str = "Hello";
str.erase(3);  // 删除位置为3的字符，结果为"Helo"

2. 删除一段子字符串：

std::string str = "Hello World";
str.erase(6, 5);  // 删除从位置6开始的5个字符，结果为"Hello"

3. 清空整个字符串：

std::string str = "Hello";
str.clear();  // 清空字符串，结果为""

erase( )和clear( )函数会修改原始字符串
erase()函数还可以接受迭代器作为参数，用于删除指定范围的字符或子字符串，灵活性更高

string 查找操作

使用find()函数可以查找子字符串在字符串中的位置，还有其他重载形式的函数如rfind()可以从后往前查找，find_first_of()可以查找字符集合中的任意字符等。

1. 查找子字符串的位置：

std::string str = "Hello World";
std::string substr = "Wor";
size_t pos = str.find(substr);  // 查找子字符串的位置，结果为6

//find()函数会返回第一次出现子字符串的位置。如果找到了子字符串，则返回其起始位置；
//如果没有找到，则返回std::string::npos，即一个特殊的常量。

2. 查找字符的位置：

std::string str = "Hello";
char ch = 'o';
size_t pos = str.find(ch);  // 查找字符的位置，结果为4

//size_t 类型表示C中任何对象所能达到的最大长度
//在32位系统上定义为 unsigned int，也就是32位无符号整型。在64位系统上定义为 unsigned long 

3. 检查子字符串是否存在：

std::string str = "Hello World";
std::string substr = "Wor";
bool exists = (str.find(substr) != std::string::npos);  // 检查子字符串是否存在

std::string::npos:

是C++标准库中的一个特殊常量，其作用是表示在字符串操作中未找到匹配的位置。它的定义如下：

static const size_t npos = -1;

• std::string::npos的值被定义为-1，通常被用作字符串查找、比较和替换等操作的返回值。
• 当某个操作无法找到或匹配特定的子字符串或字符时，返回值就是std::string::npos。
• 在使用find()函数进行字符串查找时，如果找不到目标子字符串，find()函数会返回std::string::npos，表示没有找到任何匹配的位置。

string替换操作

使用replace()函数可以替换字符串中的字符或子字符串。

1. 替换子字符串:

std::string str = "Hello, World!";
std::string oldStr = "World";
std::string newStr = "GPT";
size_t pos = str.find(oldStr);  // 查找要替换的子字符串的位置
while (pos != std::string::npos) {
    str.replace(pos, oldStr.length(), newStr);  // 进行替换操作
    pos = str.find(oldStr, pos + newStr.length());  // 继续查找下一个要替换的位置
}

2. 替换单个字符：

std::string str = "Hello, World!";
char oldChar = ',';  // 要被替换的字符
char newChar = '.';  // 替换后的字符
std::replace(str.begin(), str.end(), oldChar, newChar);  // 使用std::replace()进行替换操作

std::replice( ):
用str替换指定字符串从起始位置pos开始长度为len的字符:

tring& replace (size_t pos, size_t len, const string& str); 

string字符串长度和容量

使用length()函数可以获取字符串的长度（字符个数），使用size()函数也可以获取字符串的长度
使用capacity()函数可以获取字符串的容量

1. 字符串长度：

std::string str = "Hello, World!";
int length = str.length();  // 或者使用 str.size();

2. 字符串容量：

字符串容量表示为了存储字符串而分配的内存空间大小。

std::string str = "Hello, World!";
int capacity = str.capacity();

apacity() 返回的是字符串内部当前分配的内存空间的大小，并不一定等于字符串的长度。
当字符串超过当前容量时，std::string 类会自动重新分配更大的内存空间，以适应更长的字符串。
如果希望手动缩减字符串的内存空间，可以使用成员函数 shrink_to_fit()。

std::string str = "Hello, World!";
str.shrink_to_fit();  // 缩减字符串的内存空间

样会将字符串的容量调整为与长度相匹配。

string判断空字符串

使用empty()函数可以判断字符串是否为空。

1. 使用 empty() 函数：

std::string str = "Hello, World!";
if (str.empty()) {
    // 字符串为空
} else {
    // 字符串非空
}
//empty() 函数返回一个布尔值，如果字符串为空，则返回 true，否则返回 false。

2. 使用 length() 或 size() 函数进行长度比较：

std::string str = "Hello, World!";
if (str.length() == 0) {
    // 字符串为空
} else {
    // 字符串非空
}

string比较操作

使用compare()函数可以比较两个字符串的大小关系，还有其他重载形式的函数如<、>、<=、>=等可以直接进行比较判断。

1. 使用相等运算符 == 进行相等比较：

std::string str1 = "Hello";
std::string str2 = "World";

if (str1 == str2) {
    // 字符串相等
} else {
    // 字符串不相等
}

//如果两个字符串完全相同，则返回 true，否则返回 false。

2. 使用关系运算符进行大小比较：

std::string str1 = "Hello";
std::string str2 = "World";

if (str1 < str2) {
    // str1 小于 str2
} else if (str1 > str2) {
    // str1 大于 str2
} else {
    // str1 等于 str2
}

如果按照字典顺序，str1 小于 str2，则返回 true；如果 str1 大于 str2，则返回 true；如果两个字符串相等，则返回 false。

3. 使用成员函数 compare() 进行比较：

std::string str1 = "Hello";
std::string str2 = "World";

int result = str1.compare(str2);
if (result < 0) {
    // str1 小于 str2
} else if (result > 0) {
    // str1 大于 str2
} else {
    // str1 等于 str2
}

string 子字符串提取

使用substr()函数可以从原字符串中提取出子字符串。
substr() 函数接受两个参数：要提取的子字符串的起始索引和子字符串的长度。

#include <iostream>
#include <string>

int main() {
    std::string str = "Hello, World!";
    
    // 提取从索引位置 7 开始的子字符串，长度为 5
    std::string subStr = str.substr(7, 5);
    
    std::cout << subStr << std::endl;  // 输出 "World"
    
    return 0;
}

substr() 函数的第一个参数是子字符串的起始索引，从 0 开始计数。第二个参数是子字符串的长度。如果省略第二个参数，则提取从起始索引到字符串末尾的所有字符。

string字符串转换

可以使用c_str()函数将string对象转换为C风格字符串，使用stoi()、stof()等函数可以将字符串转换为整数、浮点数等。

1. 字符串转整数

• 使用 td::stoi进行转换:

std::string str = "123";
int num = std::stoi(str);

• 使用std::stol进行长整型转换，使用std::stoll进行长长整型转换。

2. 字符串转浮点数：

• 使用std::stof进行单精度浮点数转换，使用std::stod 行双精度浮点数转换

std::string str = "3.14";
float f = std::stof(str);
double d = std::stod(str);

3. 整数/浮点数转字符串：

• 使用 std::to_string 进行整数转字符串:

int num = 123;
std::string str = std::to_string(num);

• 使用 std::to_string 进行浮点数转字符串:

float f = 3.14;
std::string str = std::to_string(f);

以上方法在转换过程中会抛出std::invalid_argument或std::out_of_range异常，如果字符串无法正确转换为目标类型，或者超出了目标类型的范围。