std::string_view 生命周期陷阱
面试考点
std::string_view 是 C++17 引入的轻量级字符串视图。面试官通过这道题考察你是否理解 string_view 不拥有数据、不延长临时对象的生命周期,从而在特定场景下会产生悬空引用。
核心概念
std::string_view 内部只有一个指向字符数组的指针和一个长度值,它不拥有数据。当被引用的字符串被销毁后,string_view 就变成了悬空视图,访问它是未定义行为。和 const std::string& 不同,string_view 不会延长临时对象的生命周期。
基本示例
#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_view | const 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 不延长临时对象的生命周期。