C++ 学习之string容器

C++ string字符串构造函数

在C++中，标准库中的std::string类提供了多种构造函数，可以用于不同情况下对字符串进行初始化和构造。以下是std::string类常见的构造函数及其使用情况：

1. 默认构造函数：

   std::string str;
   

   用于创建一个空字符串对象。

2. 带参数的构造函数：

   std::string str("Hello, World!");
   

   用于通过字符串字面值或者C风格的字符串初始化字符串对象。

3. 复制构造函数：

   std::string str1("Hello");
   std::string str2(str1);
   

   用于通过现有的字符串对象创建一个新的字符串对象。

4. 构造指定长度的字符串：

   std::string str(5, 'A');
   

   创建一个包含5个字符’A’的字符串对象。

5. 使用迭代器区间进行构造：

   std::string str1("Hello");
   std::string str2(str1.begin(), str1.end());
   

   通过迭代器区间构造字符串对象。

6. 使用子串构造：

   std::string str1("Hello, World!");
   std::string str2 = str1.substr(0, 5);
   

   通过取原字符串的子串构造新的字符串对象。

7. 使用移动语义构造：

   std::string str1("Hello");
   std::string str2(std::move(str1));
   

   使用移动构造函数将原字符串对象的资源所有权转移到新的字符串对象。

C++ string字符串赋值操作

在C++中，std::string类提供了多种赋值操作，可用于字符串的赋值、替换和连接等操作。以下是std::string类常见的赋值操作及其使用情况：

1. 使用赋值运算符=：

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

   将一个字符串对象的值赋给另一个字符串对象。

2. 使用赋值函数assign()：

   std::string str;
   str.assign("Hello");
   

   将一个字符串的值赋给另一个字符串对象。

3. 使用子串赋值函数substr()：

   std::string str1 = "Hello";
   std::string str2 = str1.substr(0, 3);
   

   将一个字符串的子串赋给另一个字符串对象。

4. 使用+=操作符进行字符串连接：

   std::string str = "Hello";
   str += ", World!";
   

   将一个字符串与另一个字符串进行连接操作。

5. 使用append()函数进行字符串连接：

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

   使用append()函数将一个字符串追加到另一个字符串之后。

6. 使用insert()函数插入子串：

   std::string str = "Hello world!";
   str.insert(5, "beautiful ");
   

   在指定位置插入子串到字符串中。

7. 使用replace()函数替换子串：

   std::string str = "Hello, Bob!";
   str.replace(7, 3, "Alice");
   

   将字符串中指定位置的子串替换为新的子串。

C++ string字符串拼接

在C++中，可以使用多种方法来拼接字符串(std::string)对象。以下是几种常见的拼接字符串的方法：

1. 使用"+"运算符：

   std::string str1 = "Hello";
   std::string str2 = " World!";
   std::string result = str1 + str2;
   

2. 使用append()函数：

   std::string str1 = "Hello";
   std::string str2 = " World!";
   str1.append(str2);
   

3. 使用+=运算符：

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

4. 使用insert()函数插入子串：

   std::string str1 = "Hello";
   std::string str2 = " World!";
   str1.insert(str1.length(), str2); 
   

5. 使用replace()函数替换子串：

   std::string str = "Hello!";
   std::string replacement = " World!";
   str.replace(str.length(), 0, replacement);
   

C++ string字符串查找和替换

在C++中，可以使用std::string类提供的函数来进行字符串的查找和替换操作。以下是几种常见的情况：

1. 查找子串：

   使用find()函数或rfind()函数来查找字符串中第一次出现或最后一次出现指定子串的位置。如果找到，则返回子串第一个字符在原字符串中的索引；如果未找到，则返回std::string::npos。

   std::string str = "Hello, World!";
   size_t pos = str.find("World");
   if (pos != std::string::npos) {
       // 找到了
       // 处理逻辑...
   } else {
       // 未找到
       // 处理逻辑...
   }
   

2. 替换子串：

   使用replace()函数来将原字符串中指定的子串替换为新的子串。

   std::string str = "Hello, Bob!";
   str.replace(7, 3, "Alice");
   // 结果：Hello, Alice!
   

3. 全局替换子串：

   可以利用循环结合find()函数和replace()函数，实现全局替换字符串中所有出现的指定子串。

   std::string str = "Hello, Bob! Bob, hello!";
   size_t pos = str.find("Bob");
   while (pos != std::string::npos) {
       str.replace(pos, 3, "Alice");
       pos = str.find("Bob", pos + 1);
   }
   // 结果：Hello, Alice! Alice, hello!
   

4. 字符串切片和部分替换：

   利用substr()函数、加号运算符和replace()函数，可以实现对字符串中特定部分的切片和替换。

   std::string str = "Hello, World!";
   std::string slice = str.substr(7, 5); // 获取子串 "World"
   slice += " Alice"; // 拼接新的子串
   str.replace(7, 5, slice); // 替换原字符串中的子串
   // 结果：Hello, Alice!
   

C++ string字符串比较

在C++中，可以使用std::string类提供的函数来进行字符串比较操作。以下是几种常见的字符串比较方式：

1. 使用compare()函数：

   compare()函数用于比较两个字符串的大小关系，返回值为整数，如果字符串相等则返回0，如果当前字符串小于目标字符串则返回负数，如果当前字符串大于目标字符串则返回正数。

   std::string str1 = "hello";
   std::string str2 = "world";
   int result = str1.compare(str2);
   if (result == 0) {
       // 字符串相等
   } else if (result  

2. 使用运算符：

   C++中的==、!=、、=运算符可以直接用于字符串的比较，根据字符的编码进行比较。

   std::string str1 = "hello";
   std::string str2 = "world";
   if (str1 == str2) {
       // 字符串相等
   } else if (str1  

3. 使用std::lexicographical_compare()函数：

   lexicographical_compare()函数用于按照字典顺序比较两个字符串，可以自定义比较规则。

   std::string str1 = "apple";
   std::string str2 = "banana";
   if (std::lexicographical_compare(str1.begin(), str1.end(), str2.begin(), str2.end())) {
       // str1 在字典序上小于 str2
   } else {
       // str1 在字典序上大于等于 str2
   }
   

C++ string字符串存取

在C++中，可以使用std::string类提供的函数进行字符串的存取操作。以下是几种常见的方法：

1. 访问单个字符：

   可以使用下标运算符[]或者at()函数来获取字符串中特定位置的字符。

   std::string str = "Hello, World!";
   char firstChar = str[0]; // 获取第一个字符 'H'
   char fifthChar = str.at(4); // 获取第五个字符 'o'
   

2. 修改单个字符：

   可以通过下标运算符[]或者at()函数来修改字符串中特定位置的字符。

   std::string str = "Hello, World!";
   str[7] = 'E'; // 修改第八个字符为 'E'
   str.at(8) = 'A'; // 修改第九个字符为 'A'
   

3. 获取子串（字符串切片）：

   使用substr()函数可以获取原字符串中特定范围的子串。

   std::string str = "Hello, World!";
   std::string sub = str.substr(7, 5); // 获取从第八个字符开始，长度为5的子串 "World"
   

4. 设置子串：

   使用replace()函数可以在原字符串中指定位置替换特定长度的子串。

   std::string str = "Hello, World!";
   str.replace(7, 5, "Universe"); // 将从第八个字符开始，长度为5的子串 "World" 替换为 "Universe"
   

5. 追加字符串：

   使用+=运算符或者append()函数可以将一个字符串追加到另一个字符串的末尾。

   std::string str1 = "Hello, ";
   std::string str2 = "World!";
   str1 += str2; // 追加字符串到 str1 的末尾
   // 或者
   str1.append(str2); // 与上述相同效果
   

C++ string字符串插入和删除

在C++中，可以使用std::string类提供的函数进行字符串的插入和删除操作。以下是几种常见的方法：

1. 插入字符串：

   使用insert()函数可以在字符串的指定位置插入另一个字符串。

   std::string str = "Hello!";
   str.insert(5, ", World"); // 在第六个字符后面插入字符串 ", World"
   

2. 插入单个字符：

   使用insert()函数或者push_back()函数可以在字符串的指定位置插入单个字符。

   std::string str = "Hello";
   str.insert(5, 1, ','); // 在第六个字符后面插入逗号 ','
   str.push_back('!'); // 在字符串末尾插入感叹号 '!'
   

3. 删除子串：

   使用erase()函数可以删除字符串中指定位置的一段子串。

   std::string str = "Hello, World!";
   str.erase(5, 7); // 删除从第六个字符开始，长度为7的子串 ", World!"
   

4. 删除单个字符：

   使用erase()函数或者pop_back()函数可以删除字符串中指定位置的单个字符。

   std::string str = "Hello, World!";
   str.erase(5, 1); // 删除第六个字符 ','
   str.pop_back(); // 删除字符串末尾的一个字符 '!'
   

5. 清空字符串：

   使用clear()函数可以清空整个字符串。

   std::string str = "Hello, World!";
   str.clear(); // 清空字符串
   

C++ string字符串子串获取

在C++中，可以使用std::string类提供的substr()函数来获取字符串的子串。substr()函数允许你从原始字符串中提取一个子串，并返回给你一个新的字符串。下面是一个示例：

#include 
#include 
int main() {
    std::string str = "Hello, World!";
    
    // 从第6个字符开始（索引为5），取长度为5的子串
    std::string sub1 = str.substr(5, 5); // 结果为 " World"
    
    // 从第0个字符开始（即第一个字符），取长度为5的子串
    std::string sub2 = str.substr(0, 5); // 结果为 "Hello"
    
    // 从第7个字符开始（索引为6），取到末尾的子串
    std::string sub3 = str.substr(6); // 结果为 "World!"
    
    std::cout 
    std::cout 
    std::cout 
    c = std::toupper(c); // 将所有字符转换为大写
    // 或者 c = std::tolower(c); // 将所有字符转换为小写
}

    std::cout 
    std::cout