字符串的救赎：从 const string& 到 string_view 的演进史

#include <string>
#include <iostream>

void takes_a_string(std::string s) { // 3. s 是一个全新的对象
    // 4. 它的内部指针指向一块新的堆内存
    std::cout << "Inside function: " << s << std::endl;
} // 5. 函数结束，s 被销毁，它在堆上的内存被释放

int main() {
    // 1. my_str 对象在 main 函数的栈帧上
    //    它指向堆上的一块内存，存着字符串内容
    std::string my_str = "I am a fairly long string";

    // 2. 调用函数，my_str 作为参数被复制给 s
    takes_a_string(my_str);

    return 0;
}

flowchart TD
    subgraph Heap ["Heap (堆)"]
        style Heap fill:#d4f1f9,stroke:#87ceeb
        Buffer1["数据块1<br/>&quot;I am a fairly long string&quot;"]
        Buffer2["<b>数据块2 (新分配的副本)</b><br/>&quot;I am a fairly long string&quot;"]
    end

    subgraph Stack ["Stack (栈)"]
        style Stack fill:#d5f5e3,stroke:#82e0aa

        subgraph main_frame ["main() 调用帧"]
            style main_frame fill:#ffffff,stroke:#999
            my_str["<b>my_str (std::string)</b><br/>(位于栈上)"]
        end

        subgraph takes_a_string_frame ["takes_a_string() 调用帧"]
            style takes_a_string_frame fill:#ffffff,stroke:#999
            s["<b>s (std::string)</b><br/>(位于栈上, 是my_str的副本)"]
        end
    end

    my_str -- "内部指针指向" --> Buffer1
    s -- "内部指针指向" --> Buffer2

    subgraph Legend ["拷贝过程的代价"]
        style Legend fill:#f8f9fa,stroke:#d1d5da
        direction TB
        Copy["1.<b>堆内存分配</b>：为 s 在堆上请求一块新内存 (数据块2)。这是一个较慢的系统调用。"]
        Copy2["2.<b>逐字节复制</b>：将数据块1的内容，一个字符一个字符地复制到数据块2。"]
    end

    linkStyle 0 stroke:#007bff,stroke-width:2px
    linkStyle 1 stroke:#dc3545,stroke-width:2px

void takes_a_string_ref(const std::string& s) {
    std::cout << "Inside function: " << s << std::endl;
}

int main() {
    std::string my_str = "I am a fairly long string...";

    // 几乎零成本！
    // 没有发生拷贝。s 只是 my_str 的一个别名。
    takes_a_string_ref(my_str);
}

// 你的代码看起来只有一行：
takes_a_string_ref("I am a literal");

// 但编译器在背后等效执行的操作更像是这样：
{
    // 1. 创建临时对象（涉及堆分配和数据拷贝）
    std::string __temp_string("I am a literal");

    // 2. 将引用绑定到临时对象
    takes_a_string_ref(__temp_string);

} // 3. 临时对象在这里被销毁（涉及堆内存释放）

std::string source = "hello world";
// substr() 方法会创建一个包含 "hello" 的**新的** std::string 对象
// 然后再将这个临时的新对象传递给函数，开销一样存在！
takes_a_string_ref(source.substr(0, 5));

// 在 std::string_view 的定义中（简化版）
class string_view {
public:
    // ... 其他成员 ...

    // 这个构造函数不是 explicit 的！
    // 它可以从一个 std::string 隐式地构造一个 string_view
    string_view(const std::string& str) noexcept
        : ptr_(str.data()), size_(str.size())
    {
        // 构造函数的全部工作就是：
        // 1. "借用" str 内部数据的指针
        // 2. "借用" str 的大小
        // 完成！没有堆分配，没有数据拷贝。
    }
};

#include <string>
#include <string_view>

void printStringView(std::string_view sv) { /* ... */ }

int main() {
    std::string my_str = "hello";

    // ---- 场景一：我们现在的幸福生活 (隐式转换) ----
    // 因为 string_view(const std::string&) 构造函数不是 explicit，
    // 编译器被允许在背后自动调用它，来完成从 string 到 string_view 的转换。
    // 我们写的代码简洁明了：
    printStringView(my_str);


    // ---- 场景二：如果我们想“明确”一点 (显式转换) ----
    // 我们当然也可以不依赖编译器，自己手动、显式地调用构造函数。
    // 效果完全一样，只是代码啰嗦了一点：
    printStringView(std::string_view(my_str));


    // ---- 场景三：平行宇宙中的“不幸生活” ----
    // 假设，string_view 的设计者当初把构造函数标记成了 explicit:
    // explicit string_view(const std::string& str);
    //
    // 那么，场景一的代码将会直接编译失败！
    // printStringView(my_str); // 编译错误！编译器被禁止进行隐式转换
    //
    // 在这个“不幸”的平行宇宙里，你将被迫只能使用场景二的写法，
    // 每次都得手动进行显式转换。
}

flowchart LR
    subgraph Stack ["Stack (栈)"]
        style Stack fill:#d5f5e3,stroke:#82e0aa

        subgraph StringObject ["my_str (std::string)"]
            style StringObject fill:#ffffff,stroke:#999
            ptr_s["指针: 0xAAAA"]
            size_s["大小: 13"]
        end

        subgraph StringViewObject ["sv (临时 std::string_view)"]
            style StringViewObject fill:#ffffff,stroke:#999
            ptr_sv["指针: 0xAAAA"]
            size_sv["大小: 13"]
        end
    end

    subgraph Heap ["Heap (堆)"]
        style Heap fill:#d4f1f9,stroke:#87ceeb
        Buffer["数据: "I am a string" (位于地址 0xAAAA)"]
    end

    ptr_s -- "指向" --> Buffer

    subgraph Conversion ["转换过程"]
        style Conversion fill:#f8f9fa,stroke:#d1d5da
        StringObject -- "1.借用指针" --> ptr_sv
        StringObject -- "2.借用大小" --> size_sv
    end

    ptr_sv -- "也指向" --> Buffer

    linkStyle 0 stroke:#007bff,stroke-width:2px;
    linkStyle 1 stroke:#28a745,stroke-width:2px,stroke-dasharray: 5 5;
    linkStyle 2 stroke:#28a745,stroke-width:2px,stroke-dasharray: 5 5;
    linkStyle 3 stroke:#007bff,stroke-width:2px,stroke-dasharray: 2 2;

void Logger::log(const std::string& message) {
    // ... 将消息写入文件或控制台 ...
}

// 在一个每秒执行数千次的循环中
while (isRunning) {
    // ... 处理核心逻辑 ...

    // 记录各种状态，通常使用字符串字面量
    g_logger.log("Engine status: running");

    int objects_processed = process_objects();

    // 使用 sprintf 或 std::format 格式化字符串，结果通常是 char[]
    char buffer[128];
    snprintf(buffer, sizeof(buffer), "Processed %d objects", objects_processed);
    g_logger.log(buffer); // 又一次临时 std::string 的创建！
}

// 核心处理函数，接收一个“键”
void process_key(const std::string& key) {
    // ...
}

void parse_line(const std::string& line) {
    // string::find 和 string::substr 配合使用
    size_t pos = line.find('=');
    if (pos != std::string::npos) {
        // 灾难点！substr() 创建了一个全新的 std::string 对象来存储 key
        std::string key = line.substr(0, pos);
        process_key(key);
    }
}

// in mini-redis project (conceptual code)
// 解析器接收一个包含部分或完整网络数据的缓冲区视图
void CommandParser::parse(std::string_view buffer) {
    while (can_parse_a_complete_command(buffer)) {
        // 从 buffer 中“切”出一个代表命令的视图，例如 "SET"
        // 注意：这里没有创建任何新的字符串对象！
        std::string_view command_view = slice_command(buffer);

        // ... 继续切分出参数的 string_view ...

        // 将这些零成本的视图传递给命令处理器
        process_command(command_view, ...);
    }
}

flowchart TD
    subgraph sg_memory ["内存中的某个地方"]
        style sg_memory fill:#d4f1f9,stroke:#87ceeb

        subgraph StringData ["字符数组: "Hello""]
            style StringData fill:#d5f5e3,stroke:#82e0aa
            direction LR
            C1["'H'"] --> C2["'e'"] --> C3["'l'"] --> C4["'l'"] --> C5["'o'"]
        end

        subgraph StringObject ["std::string 对象 (拥有数据)"]
            style StringObject fill:#ffffff,stroke:#999
            ptr_s["指针"]
            size_s["大小: 5"]
            capacity_s["容量: 15 (例如)"]
        end

        subgraph StringViewObject ["std::string_view 对象 (观察数据)"]
            style StringViewObject fill:#ffffff,stroke:#999
            ptr_sv["指针"]
            size_sv["大小: 5"]
        end

        ptr_s -- "指向自己拥有的数据" --> StringData
        ptr_sv -- "指向外部的数据" --> StringData
    end

    subgraph sg_stack ["栈上的对象"]
        style sg_stack fill:#f8f9fa,stroke:#d1d5da
        StringObject
        StringViewObject
    end

    linkStyle 0 stroke:#007bff,stroke-width:2px,stroke-dasharray: 5 5;
    linkStyle 1 stroke:#28a745,stroke-width:2px;

#include <iostream>
#include <string>
#include <string_view> // 引入头文件

// 现代方式：接受一个 std::string_view
// 这里几乎是零成本！
void printStringView(std::string_view sv) {
    std::cout << sv << std::endl;
}

int main() {
    std::string my_str = "I am a string";
    const char* c_str = "I am a C-string";

    // 1. 从 std::string 创建，零成本
    printStringView(my_str);

    // 2. 从 C 风格字符串创建，零成本
    printStringView(c_str);

    // 3. 从字符串字面量创建，零成本
    printStringView("I am a literal");

    // 4. 创建子串视图，同样零成本！
    std::string_view sub_view = my_str;
    printStringView(sub_view.substr(0, 4)); // 输出 "I am"

    return 0;
}

#include <iostream>
#include <string_view>

std::string_view get_a_view() {
    std::string local_str = "I will be destroyed soon!";
    // 错误！返回了一个指向局部变量的视图
    return local_str;
} // `local_str` 在这里被销毁了，它拥有的内存被释放

int main() {
    std::string_view sv = get_a_view();

    // 灾难发生！
    // sv 现在指向一块已经被释放的内存，它是一个“悬空视图”。
    // 下面的打印操作将导致未定义行为。
    std::cout << sv << std::endl;

    return 0;
}