std::string_view 生命周期陷阱 ​

面试考点 ​

std::string_view 是 C++17 引入的轻量级字符串视图。面试官通过这道题考察你是否理解 string_view 不拥有数据、不延长临时对象的生命周期,从而在特定场景下会产生悬空引用。

核心概念 ​

std::string_view 内部只有一个指向字符数组的指针和一个长度值,它不拥有数据。当被引用的字符串被销毁后,string_view 就变成了悬空视图,访问它是未定义行为。和 const std::string& 不同,string_view 不会延长临时对象的生命周期。

基本示例 ​

cpp
#include <iostream>
#include <string>
#include <string_view>
#include <vector>

// ============================
// 示例1:安全的用法(函数参数)
// ============================

// string_view 作为函数参数是最安全的用法
// 因为被引用的字符串在函数执行期间肯定存活
void safe_print(std::string_view sv) {
    std::cout << sv << std::endl;
}

void safe_usage() {
    std::string s = "hello";
    safe_print(s);           // OK: s 在函数调用期间存活
    safe_print("world");     // OK: 字符串字面量有静态生命周期
    safe_print(std::string("temp")); // OK: 临时对象在语句结束前存活
}

// ============================
// 示例2:悬空视图——返回临时对象的视图
// ============================

// 危险!返回临时 string 的视图
std::string_view dangerous_return() {
    std::string s = "hello";
    return s;  // 返回后 s 被销毁,视图悬空!
}

// 危险!返回 substr 结果的视图
std::string_view dangerous_substr(const std::string& s) {
    // string::substr() 返回一个临时 string
    // 这个临时 string 在 return 后被销毁
    return s.substr(0, 5);  // 悬空!
}

// 安全的替代方案
std::string safe_substr(const std::string& s) {
    return s.substr(0, 5);  // 返回 string,有所有权
}

void dangling_return_demo() {
    // auto sv = dangerous_return();
    // std::cout << sv << std::endl;  // 未定义行为!

    // auto sv2 = dangerous_substr("hello world");
    // std::cout << sv2 << std::endl;  // 未定义行为!

    auto s = safe_substr("hello world");
    std::cout << s << std::endl;  // OK
}

// ============================
// 示例3:悬空视图——局部变量绑定临时对象
// ============================

void dangling_local_demo() {
    // 危险!string_view 绑定到临时 string
    std::string_view sv = std::string("temporary");
    // 临时 string 在这行结束时销毁
    // sv 现在是悬空的!
    // std::cout << sv << std::endl;  // 未定义行为!

    // 对比:const string& 会延长临时对象的生命周期
    const std::string& ref = std::string("temporary");
    std::cout << ref << std::endl;  // OK,生命周期被延长

    // 安全的写法
    std::string str = "safe";
    std::string_view sv_safe = str;  // OK,str 比 sv_safe 活得久
    std::cout << sv_safe << std::endl;
}

// ============================
// 示例4:悬空视图——字符串拼接
// ============================

void dangling_concat_demo() {
    std::string a = "hello";
    std::string b = " world";

    // 危险!a + b 产生临时 string,语句结束后销毁
    std::string_view sv = a + b;
    // std::cout << sv << std::endl;  // 未定义行为!

    // 安全的写法
    std::string result = a + b;
    std::string_view sv_safe = result;
    std::cout << sv_safe << std::endl;  // OK
}

// ============================
// 示例5:悬空视图——存储在容器或类成员中
// ============================

class Config {
    // 危险!存储 string_view 作为成员
    // std::string_view name_;  // 谁保证 name_ 引用的数据还活着?

    // 安全的做法:存储 string
    std::string name_;

public:
    // 参数用 string_view(高效),内部存储用 string(安全)
    void set_name(std::string_view name) {
        name_ = name;  // 隐式转换为 string,拷贝数据
    }

    std::string_view get_name() const {
        return name_;  // OK,name_ 是成员,生命周期和对象一样
    }
};

void member_demo() {
    Config cfg;
    cfg.set_name("test_config");
    std::cout << cfg.get_name() << std::endl;

    // 危险模式:
    // std::vector<std::string_view> views;
    // for (int i = 0; i < 5; i++) {
    //     std::string s = "item_" + std::to_string(i);
    //     views.push_back(s);  // s 在循环结束后销毁,view 悬空!
    // }

    // 安全模式:
    std::vector<std::string> strings;
    for (int i = 0; i < 5; i++) {
        strings.push_back("item_" + std::to_string(i));
    }
    // 现在可以安全创建视图(strings 活着)
    std::vector<std::string_view> views(strings.begin(), strings.end());
    for (auto sv : views) {
        std::cout << sv << " ";
    }
    std::cout << std::endl;
}

// ============================
// 示例6:string_view 和 string 的隐式转换
// ============================

void conversion_demo() {
    // string -> string_view:隐式转换(安全,只要 string 活着)
    std::string s = "hello";
    std::string_view sv = s;  // 隐式

    // string_view -> string:需要显式转换(有拷贝开销)
    std::string s2(sv);          // 构造
    std::string s3 = std::string(sv); // 显式

    // 这种设计是故意的:
    // 转成 string_view 很便宜(不拷贝),所以隐式
    // 转成 string 有拷贝开销,所以要显式
}

// ============================
// 示例7:安全使用 string_view 的规则
// ============================

/*
安全规则总结:
1. 函数参数用 string_view:最安全,最推荐
2. 不要从函数返回 string_view(除非返回成员或静态数据)
3. 不要用 string_view 绑定临时 string
4. 不要存储 string_view 作为类成员(除非能保证生命周期)
5. 不要把 string_view 放进容器(除非能保证源数据存活)
6. 参数用 string_view,存储用 string
*/

int main() {
    std::cout << "=== 安全用法 ===" << std::endl;
    safe_usage();

    std::cout << "\n=== 悬空返回 ===" << std::endl;
    dangling_return_demo();

    std::cout << "\n=== 悬空局部变量 ===" << std::endl;
    dangling_local_demo();

    std::cout << "\n=== 悬空拼接 ===" << std::endl;
    dangling_concat_demo();

    std::cout << "\n=== 成员存储 ===" << std::endl;
    member_demo();

    return 0;
}

string_view 安全性速查 ​

场景是否安全原因
函数参数安全调用期间源数据存活
绑定字符串字面量安全字面量有静态生命周期
绑定局部 string安全只要 string 比 view 活得久
绑定临时 string危险临时对象语句结束后销毁
绑定 string 拼接结果危险拼接产生临时对象
从函数返回危险局部 string 销毁后悬空
存储为类成员危险难以保证源数据生命周期
放入容器危险源数据可能先于容器销毁

string_view vs const string& ​

特性string_viewconst string&
接受 const char*不需要构造 string需要构造临时 string
延长临时对象生命周期不延长延长
支持子串可以指向子串不可以
sizeof通常 16 字节通常 8 字节(指针)
拷贝开销极低(拷贝指针+长度)无(引用)

常见问题 ​

为什么 string_view 不延长临时对象的生命周期?

生命周期延长是 C++ 引用的特殊规则,只对直接绑定到引用的临时对象生效。string_view 不是引用,它是一个普通对象(包含指针和长度),所以临时对象在构造 string_view 后就可以被销毁了。

string::substr() 返回 string 还是 string_view?

std::string::substr() 返回 std::string(新的拷贝)。这意味着 string_view sv = s.substr(0, 5); 会绑定到一个临时 string,非常危险。C++23 中可以用 string_view 自己的 substr(),它返回 string_view,但仍然需要注意源数据的生命周期。

函数参数用 string_view 还是 const string&?

如果函数只是读取字符串内容,推荐用 string_view。它同时接受 string、const char*、string_view,不需要构造临时 string。如果函数内部要存储字符串,参数仍然用 string_view,但内部转成 string 存储。

适用场景 ​

  • 函数参数(只读访问字符串)
  • 解析和分词(避免大量子串拷贝)
  • 接受多种字符串类型的统一接口

注意事项 ​

  • string_view 不拥有数据,不延长临时对象生命周期
  • 不要返回指向局部 string 的 string_view
  • 参数用 string_view,存储用 string
  • 注意 string::substr() 返回的是临时 string
  • 编译器通常不会对悬空 string_view 发出警告

总结 ​

string_view 是高效的字符串只读视图,但它不拥有数据。最大的陷阱是绑定到临时 string(拼接结果、substr 结果、函数返回值),临时对象销毁后 string_view 悬空。安全规则:函数参数用 string_view,存储用 string,不要返回指向局部数据的 string_view。面试中要能列举至少三种悬空 string_view 的场景,解释为什么 string_view 不延长临时对象的生命周期。