【C++】C++ 标准库string类介绍(超详细解析，小白必看系列）

C++ 标准库中的 std::string 类是一个非常强大的工具，用于处理和操作字符串。它属于 <string> 头文件，并提供了一套丰富的功能和方法。以下是 std::string 类的一些主要特性和常用操作：

1 string简介

1.  字符串是表示字符序列的类
2.  标准的字符串类提供了对此类对象的支持，其接口类似于标准字符容器的接口，但添加了专门用于操作单字节字符字符串的设计特性。
3. string类是使用char(即作为它的字符类型，使用它的默认char_traits和分配器类型(关于模板的更多信 息，请参阅basic_string)。
4. string类是basic_string模板类的一个实例，它使用char来实例化basic_string模板类，并用char_traits 和allocator作为basic_string的默认参数(根于更多的模板信息请参考basic_string)。
5.  注意，这个类独立于所使用的编码来处理字节:如果用来处理多字节或变长字符(如UTF-8)的序列，这个 类的所有成员(如长度或大小)以及它的迭代器，将仍然按照字节(而不是实际编码的字符)来操作。

总结：

1.  string是表示字符串的字符串类
2. 该类的接口与常规容器的接口基本相同，再添加了一些专门用来操作string的常规操作。
3. string在底层实际是：basic_string模板类的别名，typedef basic_string<char, char_traits, allocator> string;
4. 不能操作多字节或者变长字符的序列。
5. 在使用string类时，必须包含#include头文件以及using namespace std;

2 string类的常用接口说明

1. 构造函数和赋值操作

• 默认构造函数：创建一个空字符串。
• 带字符串参数的构造函数：可以用 C 风格字符串（如 const char*）来初始化。
• 拷贝构造函数：用另一个 std::string 对象来初始化。
• 赋值操作符：可以将一个字符串赋值给另一个字符串。

std::string str1; // 默认构造函数
std::string str2 = "Hello, World!"; // 带字符串参数的构造函数
std::string str3 = str2; // 拷贝构造函数
std::string str4;
str4 = "World, Hello!"; // 赋值操作

2. 容量操作

• length() 和 size()：返回字符串的长度。
• capacity()：返回字符串的容量。
• empty()：检查字符串是否为空。
• clear()：清空字符串。
• reserve()：为字符串预留空间。
• resize()：调整字符串的大小。

std::string myString = "Hello, World!";
std::cout << "Length: " << myString.length() << std::endl;
std::cout << "Capacity: " << myString.capacity() << std::endl;
std::cout << "Is empty? " << (myString.empty() ? "Yes" : "No") << std::endl;
myString.clear();
std::cout << "After clear: " << myString << std::endl;
myString.reserve(20);
myString.resize(10, 'X');
std::cout << "After resizing: " << myString << std::endl;

3. 访问及遍历操作

• operator[]：通过下标访问字符串中的字符。
• begin() 和 end()：获取字符串的迭代器，用于遍历字符串。
• rbegin() 和 rend()：获取字符串的反向迭代器，用于反向遍历字符串。
• 范围 for 循环：C++11 引入的简洁遍历方式。

const std::string myString = "Hello, World!";
char character = myString[7];
std::cout << "Character at position 7: " << character << std::endl;for (auto it = myString.begin(); it != myString.end(); ++it) {std::cout << *it << " ";
}
std::cout << std::endl;for (auto rit = myString.rbegin(); rit != myString.rend(); ++rit) {std::cout << *rit << " ";
}
std::cout << std::endl;

4. 修改操作

• operator+= 和 append()：拼接字符串。
• insert()：在指定位置插入字符串。
• erase()：删除指定位置的字符或子串。
• replace()：替换指定位置的字符或子串。

std::string str = "Hello";
str += ", World!";
str.append(" How are you?");
str.insert(5, " there");
str.erase(5, 6);
str.replace(0, 5, "Hi");
std::cout << str << std::endl;

5. 查找操作

• find() 和 rfind()：查找子串的位置。
• substr()：获取子串。

std::string str = "Hello, World!";
size_t pos = str.find("World");
if (pos != std::string::npos) {std::cout << "Found 'World' at position: " << pos << std::endl;
}
std::string sub = str.substr(7, 5);
std::cout << "Substring: " << sub << std::endl;

6. vs和g++下string结构的说明

在 Visual Studio (VS) 和 GNU Compiler Collection (GCC) 下，std::string 类的实现有一些差异。以下是对这两种环境下 std::string 结构的简要说明：

1 Visual Studio 下的 std::string 结构

在 Visual Studio 中，std::string 类的实现较为复杂，通常包含以下几个部分：

1. 指针：指向实际存储字符串数据的内存。
2. 大小：表示字符串的长度。
3. 容量：表示分配的内存容量。

Visual Studio 使用了 Small String Optimization (SSO) 技术，当字符串较短时，数据会直接存储在对象内部，而不需要额外的动态内存分配。这种优化可以提高性能，减少内存分配的开销

2 GCC 下的 std::string 结构

G++下，string是通过写时拷贝实现的，string对象总共占4个字节，内部只包含了一个指针，该指

针将来指向一块堆空间，内部包含了如下字段：

1. 空间总大小
2. 字符串有效长度
3. 引用计数

3 写时拷贝的工作原理

1. 共享数据：当一个 std::string 对象被复制时，新的对象不会立即复制字符串数据，而是共享原始字符串的数据。这意味着多个 std::string 对象可以指向同一块内存。
2. 引用计数：每个共享的数据块都有一个引用计数，记录有多少个 std::string 对象共享这块数据。
3. 写时复制：当任何一个 std::string 对象试图修改共享的数据时，会先检查引用计数。如果引用计数大于1，表示数据被多个对象共享，此时会创建数据的真实副本，然后对这个副本进行修改。这样，修改操作不会影响其他共享同一数据的对象。

示例代码

以下是一个简单的写时拷贝实现示例：

#include <iostream>
#include <cstring>class String {
public:String(const char* str = "") {if (str) {m_data = new char[strlen(str) + 1];strcpy(m_data, str);m_refCount = new int(1);} else {m_data = new char[1];*m_data = '\0';m_refCount = new int(1);}}String(const String& other) {m_data = other.m_data;m_refCount = other.m_refCount;++(*m_refCount);}~String() {if (--(*m_refCount) == 0) {delete[] m_data;delete m_refCount;}}String& operator=(const String& other) {if (this != &other) {if (--(*m_refCount) == 0) {delete[] m_data;delete m_refCount;}m_data = other.m_data;m_refCount = other.m_refCount;++(*m_refCount);}return *this;}char& operator {if (*m_refCount > 1) {char* newData = new char[strlen(m_data) + 1];strcpy(newData, m_data);--(*m_refCount);m_data = newData;m_refCount = new int(1);}return m_data[index];}const char* c_str() const {return m_data;}private:char* m_data;int* m_refCount;
};int main() {String str1("Hello");String str2 = str1;str2[0] = 'h';std::cout << "str1: " << str1.c_str() << std::endl;std::cout << "str2: " << str2.c_str() << std::endl;return 0;
}

现代 C++ 标准中的变化

在 C++11 及之后的标准中，std::string 类的实现已经不再使用写时拷贝技术。原因包括：

• 线程安全性：写时拷贝需要维护引用计数，这在多线程环境中会引入复杂的同步问题。
• 性能考虑：现代 C++ 标准更倾向于使用移动语义和右值引用来优化性能，而不是依赖写时拷贝