C++字符串操作技巧及string方法详解

C++中string类提供构造、赋值、访问、修改、查找、比较等丰富操作，支持自动内存管理，相比C风格字符串更安全高效，通过reserve预分配内存可优化拼接性能，使用at()可避免越界访问，需注意空指针和迭代器失效等问题。

C++中string类提供了丰富的功能来处理字符串，理解并熟练运用这些方法是高效进行C++字符串操作的关键。下面将详细介绍string类的常用操作方法。

解决方案

C++的string类封装了许多字符串操作，包括构造、修改、查找、比较等。掌握这些操作能够更有效地处理字符串数据。

• 构造函数：

  • string()：默认构造函数，创建一个空字符串。
  • string(const string& str)：拷贝构造函数，用另一个string对象初始化。
  • string(const char* s)：用C风格字符串初始化。
  • string(size_t n, char c)：用n个字符c初始化。

• 赋值：

  • string& operator=(const string& str)：将一个string对象赋值给另一个。
  • string& operator=(const char* s)：将C风格字符串赋值给string对象。
  • string& operator=(char c)：将单个字符赋值给string对象。
  • string& assign(const string& str)：赋值，功能与=类似，但更灵活。
  • string& assign(const char* s)：赋值，功能与=类似，但更灵活。
  • string& assign(size_t n, char c)：赋值，用n个字符c赋值。

• 访问：

  • char& operator[](size_t pos)：访问指定位置的字符，不进行越界检查。
  • char& at(size_t pos)：访问指定位置的字符，进行越界检查，越界会抛出std::out_of_range异常。
  • char& front()：访问第一个字符。
  • char& back()：访问最后一个字符。

• 修改：

  • string& append(const string& str)：在字符串末尾追加另一个字符串。
  • string& append(const char* s)：在字符串末尾追加C风格字符串。
  • string& append(size_t n, char c)：在字符串末尾追加n个字符c。
  • string& push_back(char c)：在字符串末尾追加一个字符。
  • string& insert(size_t pos, const string& str)：在指定位置插入另一个字符串。
  • string& insert(size_t pos, const char* s)：在指定位置插入C风格字符串。
  • string& insert(size_t pos, size_t n, char c)：在指定位置插入n个字符c。
  • string& erase(size_t pos = 0, size_t n = npos)：删除从指定位置开始的n个字符。
  • string& replace(size_t pos, size_t n, const string& str)：替换从指定位置开始的n个字符为另一个字符串。
  • string& replace(size_t pos, size_t n, const char* s)：替换从指定位置开始的n个字符为C风格字符串。
  • void clear()：清空字符串。
  • string& resize(size_t n)：改变字符串长度为n，如果n大于当前长度，则用空格填充。
  • string& resize(size_t n, char c)：改变字符串长度为n，如果n大于当前长度，则用字符c填充。

• 查找：

  • size_t find(const string& str, size_t pos = 0) const：从指定位置开始查找子字符串，返回第一次出现的位置，找不到返回string::npos。
  • size_t find(const char* s, size_t pos = 0) const：从指定位置开始查找C风格字符串，返回第一次出现的位置，找不到返回string::npos。
  • size_t find(char c, size_t pos = 0) const：从指定位置开始查找字符，返回第一次出现的位置，找不到返回string::npos。
  • size_t rfind(const string& str, size_t pos = npos) const：从指定位置开始反向查找子字符串，返回第一次出现的位置，找不到返回string::npos。
  • size_t rfind(const char* s, size_t pos = npos) const：从指定位置开始反向查找C风格字符串，返回第一次出现的位置，找不到返回string::npos。
  • size_t rfind(char c, size_t pos = npos) const：从指定位置开始反向查找字符，返回第一次出现的位置，找不到返回string::npos。
  • size_t find_first_of(const string& str, size_t pos = 0) const：从指定位置开始查找第一个在子字符串中出现的字符，返回位置，找不到返回string::npos。
  • size_t find_first_of(const char* s, size_t pos = 0) const：从指定位置开始查找第一个在C风格字符串中出现的字符，返回位置，找不到返回string::npos。
  • size_t find_first_not_of(const string& str, size_t pos = 0) const：从指定位置开始查找第一个不在子字符串中出现的字符，返回位置，找不到返回string::npos。
  • size_t find_first_not_of(const char* s, size_t pos = 0) const：从指定位置开始查找第一个不在C风格字符串中出现的字符，返回位置，找不到返回string::npos。
  • size_t find_last_of(const string& str, size_t pos = npos) const：从指定位置开始反向查找第一个在子字符串中出现的字符，返回位置，找不到返回string::npos。
  • size_t find_last_of(const char* s, size_t pos = npos) const：从指定位置开始反向查找第一个在C风格字符串中出现的字符，返回位置，找不到返回string::npos。
  • size_t find_last_not_of(const string& str, size_t pos = npos) const：从指定位置开始反向查找第一个不在子字符串中出现的字符，返回位置，找不到返回string::npos。
  • size_t find_last_not_of(const char* s, size_t pos = npos) const：从指定位置开始反向查找第一个不在C风格字符串中出现的字符，返回位置，找不到返回string::npos。

• 比较：

  • int compare(const string& str) const：与另一个字符串比较。
  • int compare(const char* s) const：与C风格字符串比较。
  • bool operator==(const string& str) const：判断是否相等。
  • bool operator!=(const string& str) const：判断是否不相等。
  • bool operator<(const string& str) const：判断是否小于。
  • bool operator>(const string& str) const：判断是否大于。
  • bool operator<=(const string& str) const：判断是否小于等于。
  • bool operator>=(const string& str) const：判断是否大于等于。

• 子串：

  • string substr(size_t pos = 0, size_t n = npos) const：返回从指定位置开始的n个字符组成的子字符串。

• 其他：

  • size_t size() const：返回字符串长度。
  • size_t length() const：返回字符串长度，与size()功能相同。
  • size_t capacity() const：返回字符串的容量，即分配的内存大小。
  • bool empty() const：判断字符串是否为空。
  • const char* c_str() const：返回C风格字符串。
  • const char* data() const：返回指向字符串数据的指针，与c_str()类似，但不保证以空字符结尾。

如何高效地使用C++ string类进行字符串拼接？

使用string类进行字符串拼接时，选择合适的方法可以显著提高性能。多次使用+=或append进行拼接可能会导致频繁的内存重新分配。一个更高效的方法是预先计算好最终字符串的长度，然后使用reserve方法预留足够的内存空间，再进行拼接。 此外，如果需要拼接大量的字符串，可以考虑使用stringstream，它在某些情况下可能比直接使用string类更高效。

#include <iostream>
#include <string>
#include <sstream>

int main() {
    std::string str1 = "Hello";
    std::string str2 = "World";
    std::string result;

    // 预留空间，避免多次分配内存
    result.reserve(str1.length() + str2.length() + 1);
    result += str1;
    result += " ";
    result += str2;

    std::cout << result << std::endl;

    // 使用 stringstream
    std::stringstream ss;
    ss << str1 << " " << str2;
    std::string result2 = ss.str();

    std::cout << result2 << std::endl;

    return 0;
}

C++ string类与C风格字符串char*有什么区别和联系？

string类是C++标准库提供的字符串类，它封装了字符串的操作，具有自动内存管理的功能，可以动态地增长或缩小。而C风格字符串char*本质上是一个字符数组，需要手动管理内存，容易出现内存泄漏或缓冲区溢出等问题。

区别：

• 内存管理：string类自动管理内存，char*需要手动管理。
• 安全性：string类更安全，不容易出现缓冲区溢出。
• 功能：string类提供了丰富的字符串操作方法。

联系：

• string类可以转换为C风格字符串，通过c_str()方法。
• string类可以用C风格字符串初始化。
• 在某些情况下，需要将string对象转换为char*才能与某些C风格的API兼容。

如何避免C++ string类在使用过程中常见的错误？

在使用string类时，需要注意以下几点以避免常见的错误：

1. 越界访问： 使用operator[]访问字符串时，不会进行越界检查，如果访问越界，会导致未定义行为。应该使用at()方法，它会进行越界检查，并在越界时抛出异常。
2. 空指针： 在使用C风格字符串初始化string对象时，要确保C风格字符串不是空指针，否则会导致程序崩溃。
3. 内存泄漏： 虽然string类自动管理内存，但在某些情况下，如果将string对象赋值给char*指针，并且没有正确地管理char*指针指向的内存，仍然可能导致内存泄漏。
4. 修改const string： 不要尝试修改const string对象，否则会导致编译错误或运行时错误。
5. 迭代器失效： 在使用迭代器遍历string对象时，如果对字符串进行了修改操作，可能会导致迭代器失效。

#include <iostream>
#include <string>
#include <stdexcept>

int main() {
    std::string str = "Hello";

    // 避免越界访问
    try {
        char c = str.at(10); // 抛出 std::out_of_range 异常
        std::cout << c << std::endl;
    } catch (const std::out_of_range& e) {
        std::cerr << "Out of range error: " << e.what() << std::endl;
    }

    // 避免空指针
    const char* cstr = nullptr;
    // std::string str2(cstr); // 避免这样使用，会导致崩溃

    return 0;
}