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

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

1 string简介

字符串是表示字符序列的类

标准的字符串类提供了对此类对象的支持，其接口类似于标准字符容器的接口，但添加了专门用于操作单字节字符字符串的设计特性。

string类是使用char(即作为它的字符类型，使用它的默认char_traits和分配器类型(关于模板的更多信息，请参阅basic_string)。

string类是basic_string模板类的一个实例，它使用char来实例化basic_string模板类，并用char_traits 和allocator作为basic_string的默认参数(根于更多的模板信息请参考basic_string)。

注意，这个类独立于所使用的编码来处理字节:如果用来处理多字节或变长字符(如UTF-8)的序列，这个类的所有成员(如长度或大小)以及它的迭代器，将仍然按照字节(而不是实际编码的字符)来操作。

总结：

string是表示字符串的字符串类

该类的接口与常规容器的接口基本相同，再添加了一些专门用来操作string的常规操作。

string在底层实际是：basic_string模板类的别名，typedef basic_string<char, char_traits, allocator> string;

不能操作多字节或者变长字符的序列。

在使用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 类的实现较为复杂，通常包含以下几个部分：

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

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

2 GCC 下的 `std::string` 结构

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

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

空间总大小

字符串有效长度

引用计数

3 写时拷贝的工作原理

共享数据：当一个 std::string 对象被复制时，新的对象不会立即复制字符串数据，而是共享原始字符串的数据。这意味着多个 std::string 对象可以指向同一块内存。
引用计数：每个共享的数据块都有一个引用计数，记录有多少个 std::string 对象共享这块数据。
写时复制：当任何一个 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++ 标准更倾向于使用移动语义和右值引用来优化性能，而不是依赖写时拷贝