C++ 17 详细特性解析（6）

🎁std::string_view

std::string_view 是 C++17 标准库中引入的非拥有（non-owning）的字符视图类。它提供了一种轻量级的方式来 “查看” 一个已有的字符串（或字符数组），而无需复制其内容。你可以把它想象成一个指向现有字符串的 “望远镜” 或 “观察窗口”，它本身不分配或管理内存。

🔗 参考：https://en.cppreference.com/w/cpp/header/string_view.html

std::string_view 提供和 std::string 完全类似的接口，它的设计思路是非拥有的视图，只保存原始位置的指针和长度；无所有权，不负责字符串的生命周期管理，const 视图只能观察，不能修改底层字符串。

---

💻 基础使用示例

1. #include <iostream>
2. #include <string>
3. #include <string_view>
4. #include <vector>
5. #include <algorithm>
6. #include <cctype>
8. // 基础打印函数 - 展示 string_view 的核心能力
9. void print(std::string_view sv, const std::string& title = "string_view") {
10. std::cout << "\n=== " << title << " ===\n";
11. std::cout << "内容: '" << sv << "'\n";
12. std::cout << "长度: " << sv.size() << " 字符\n";
13. std::cout << "是否为空: " << (sv.empty() ? "是" : "否") << "\n";
15. // 遍历方式1：下标访问（O(1) 随机访问）
16. std::cout << "字符(下标): ";
17. for (size_t i = 0; i < sv.size(); ++i) {
18. std::cout << sv[i] << " ";
19. }
20. std::cout << "\n";
22. // 遍历方式2：范围 for 循环（现代 C++ 风格）
23. std::cout << "字符(范围): ";
24. for (char ch : sv) {
25. std::cout << ch << " ";
26. }
27. std::cout << "\n";
29. // 遍历方式3：迭代器（算法友好）
30. std::cout << "字符(迭代器): ";
31. for (auto it = sv.begin(); it != sv.end(); ++it) {
32. std::cout << *it << " ";
33. }
34. std::cout << "\n";
35. }
37. // 实际应用：字符串分割函数（不复制数据，高效）
38. std::vector<std::string_view> split(std::string_view str, char delimiter) {
39. std::vector<std::string_view> result;
40. size_t start = 0;
42. while (start < str.size()) {
43. size_t end = str.find(delimiter, start);
44. if (end == std::string_view::npos) {
45. // 最后一部分
46. result.push_back(str.substr(start));
47. break;
48. }
49. // 添加子串（零拷贝）
50. result.push_back(str.substr(start, end - start));
51. start = end + 1;
52. }
53. return result;
54. }
56. // 实际应用：移除空格（延迟处理，不修改原字符串）
57. std::string_view trim(std::string_view str) {
58. // 移除前导空格
59. while (!str.empty() && std::isspace(static_cast<unsigned char>(str.front()))) {
60. str.remove_prefix(1);
61. }
62. // 移除尾随空格
63. while (!str.empty() && std::isspace(static_cast<unsigned char>(str.back()))) {
64. str.remove_suffix(1);
65. }
66. return str;
67. }
69. // 实际应用：判断是否为前缀
70. bool starts_with(std::string_view str, std::string_view prefix) {
71. return str.size() >= prefix.size() && str.substr(0, prefix.size()) == prefix;
72. }
74. // 实际应用：判断是否为后缀
75. bool ends_with(std::string_view str, std::string_view suffix) {
76. return str.size() >= suffix.size() &&
77. str.substr(str.size() - suffix.size()) == suffix;
78. }
80. // 实际应用：大小写不敏感比较
81. bool iequals(std::string_view a, std::string_view b) {
82. if (a.size() != b.size()) return false;
84. auto to_lower = [](char c) {
85. return std::tolower(static_cast<unsigned char>(c));
86. };
88. return std::equal(a.begin(), a.end(), b.begin(), to_lower);
89. }
91. // 性能对比演示
92. void performance_demo() {
93. std::cout << "\n=== 性能优化演示 ===\n";
95. // ❌ 低效：不必要的字符串拷贝
96. std::string huge_string(1000000, 'A');
97. auto start = std::chrono::high_resolution_clock::now();
98. std::string copy = huge_string.substr(100, 500); // 复制数据
99. auto end = std::chrono::high_resolution_clock::now();
100. auto copy_time = std::chrono::duration_cast<std::chrono::microseconds>(end - start);
101. std::cout << "字符串拷贝耗时: " << copy_time.count() << " 微秒\n";
103. // ✅ 高效：string_view 零拷贝
104. start = std::chrono::high_resolution_clock::now();
105. std::string_view view = std::string_view(huge_string).substr(100, 500); // 不复制
106. end = std::chrono::high_resolution_clock::now();
107. auto view_time = std::chrono::duration_cast<std::chrono::microseconds>(end - start);
108. std::cout << "string_view 耗时: " << view_time.count() << " 微秒\n";
109. std::cout << "性能提升: " << (double)copy_time.count() / view_time.count() << " 倍\n";
110. }
112. int main() {
113. // ========== 1. 基础构造方式 ==========
114. std::cout << "1. 基础构造方式\n" << std::string(50, '=') << "\n";
116. // 从字符串字面量构造
117. std::string_view sv1 = "Hello, world!";
118. print(sv1, "从字面量构造");
120. // 从 std::string 构造
121. std::string str = "C++17 string_view is powerful!";
122. std::string_view sv2 = str;
123. print(sv2, "从 std::string 构造");
125. // 从部分字符串构造（指针+长度）
126. std::string_view sv3(str.c_str() + 6, 11); // "string_view"
127. print(sv3, "从部分字符串构造");
129. // 使用字面量后缀（需要 using namespace std::literals）
130. using namespace std::literals;
131. std::string_view sv4 = "Literal string_view"sv;
132. print(sv4, "字面量后缀");
134. // ========== 2. 实际应用场景 ==========
135. std::cout << "\n2. 实际应用场景\n" << std::string(50, '=') << "\n";
137. // 字符串分割
138. std::string csv = "apple,banana,cherry,date";
139. auto fruits = split(csv, ',');
140. std::cout << "CSV 分割: ";
141. for (auto fruit : fruits) {
142. std::cout << "'" << fruit << "' ";
143. }
144. std::cout << "\n";
146. // 移除空格
147. std::string messy = " \t Hello, World! \n";
148. std::string_view cleaned = trim(messy);
149. std::cout << "原字符串: '" << messy << "'\n";
150. std::cout << "去除空格后: '" << cleaned << "'\n";
151. std::cout << "原字符串未修改: '" << messy << "' (证明零拷贝)\n";
153. // 前缀/后缀检查
154. std::string filename = "document.pdf";
155. std::string_view fv = filename;
156. std::cout << "文件名: " << fv << "\n";
157. std::cout << "以 'doc' 开头? " << (starts_with(fv, "doc") ? "是" : "否") << "\n";
158. std::cout << "以 '.pdf' 结尾? " << (ends_with(fv, ".pdf") ? "是" : "否") << "\n";
160. // 大小写不敏感比较
161. std::string_view str1 = "Hello";
162. std::string_view str2 = "HELLO";
163. std::cout << "忽略大小写比较: '" << str1 << "' vs '" << str2 << "' = "
164. << (iequals(str1, str2) ? "相等" : "不等") << "\n";
166. // ========== 3. 边界情况和注意事项 ==========
167. std::cout << "\n3. 边界情况和注意事项\n" << std::string(50, '=') << "\n";
169. // 空字符串视图
170. std::string_view empty;
171. print(empty, "空 string_view");
173. // 临时字符串的危险用法（演示）
174. std::cout << "⚠️ 警告：string_view 不拥有数据！\n";
175. std::string_view dangerous;
176. {
177. std::string temp = "临时字符串";
178. dangerous = temp; // 危险！temp 即将销毁
179. std::cout << "临时对象存在时: " << dangerous << "\n";
180. }
181. // dangerous 现在是悬空引用！不要取消注释下一行
182. // std::cout << "临时对象销毁后: " << dangerous << "\n"; // 未定义行为！
184. // 安全做法：确保底层数据生命周期足够长
185. std::string safe_str = "安全字符串";
186. std::string_view safe_view = safe_str;
187. std::cout << "安全使用: " << safe_view << "\n";
189. // ========== 4. find 系列操作 ==========
190. std::cout << "\n4. 查找操作\n" << std::string(50, '=') << "\n";
192. std::string_view text = "The quick brown fox jumps over the lazy dog";
193. std::cout << "文本: '" << text << "'\n";
195. auto pos = text.find("fox");
196. if (pos != std::string_view::npos) {
197. std::cout << "找到 'fox' 在位置 " << pos << "\n";
198. std::cout << "子串: " << text.substr(pos, 3) << "\n";
199. }
201. pos = text.find_first_of("aeiou");
202. if (pos != std::string_view::npos) {
203. std::cout << "第一个元音 '" << text[pos] << "' 在位置 " << pos << "\n";
204. }
206. // ========== 5. 性能演示 ==========
207. performance_demo();
209. // ========== 6. 现代 C++ 最佳实践 ==========
210. std::cout << "\n5. 最佳实践建议\n" << std::string(50, '=') << "\n";
212. // 函数参数使用 string_view
213. auto process = [](std::string_view data) {
214. // 不拷贝，只读取
215. return data.size();
216. };
218. // 可以传字符串字面量、std::string、另一个 string_view
219. std::cout << "字符串字面量长度: " << process("Hello") << "\n";
220. std::cout << "std::string 长度: " << process(std::string("World")) << "\n";
222. // 避免 string_view 悬空
223. std::cout << "\n✅ 核心原则:\n";
224. std::cout << "1. string_view 像指针一样，不拥有数据\n";
225. std::cout << "2. 确保底层数据生命周期覆盖 string_view 的使用\n";
226. std::cout << "3. 函数参数用 string_view，返回值用 string（如果需要拥有数据）\n";
227. std::cout << "4. 修改原字符串会使 string_view 失效\n";
228. std::cout << "5. string_view 不保证以 \\0 结尾，使用 .data() 要小心\n";
230. return 0;
231. }

复制代码

---

✨ 核心优势与典型场景

std::string_view 几乎是零开销，它不会复制字符串数据，构造和析构成本极低。并且提供了与 std::string 非常相似的接口，几乎提供了所有的读相关接口，并且兼容性强，它可以高效地从 std::string、字符串字面量、char* 等任何字符序列构造而来。这样在很多场景下可以减少构造和拷贝，又可以利用 string 类似的相关接口处理串。

1. /**
2. * @file string_view_core_demo.cpp
3. * @brief std::string_view 核心优势与典型场景演示
4. * @author Code Reviewer
5. * @date 2026-05-12
6. *
7. * @details 本文件展示 std::string_view 的核心特性：
8. * 1. 零拷贝（不复制字符串数据）
9. * 2. 只读访问（非拥有型视图）
10. * 3. 轻量级（仅存储指针+长度，16字节）
11. * 4. 高效子串操作（无需复制）
12. * 5. 兼容多种字符串类型（字面量、std::string、C字符串）
13. *
14. * 编译运行：
15. * g++ -std=c++17 -O2 string_view_core_demo.cpp -o core_demo
16. * ./core_demo
17. */
19. #include <iostream>
20. #include <string>
21. #include <string_view>
22. #include <vector>
23. #include <algorithm>
24. #include <cctype>
26. /**
27. * @brief 打印 string_view 的基本信息（辅助函数）
28. * @param sv 要打印的字符串视图
29. * @param title 可选的标题
30. */
31. void print_info(std::string_view sv, const std::string& title = "string_view") {
32. std::cout << "\n┌─────────────────────────────────────────┐\n";
33. std::cout << "│ " << title << "\n";
34. std::cout << "├─────────────────────────────────────────┤\n";
35. std::cout << "│ 内容: '" << sv << "'\n";
36. std::cout << "│ 长度: " << sv.size() << " 字符\n";
37. std::cout << "│ 是否为空: " << (sv.empty() ? "是" : "否") << "\n";
38. std::cout << "│ sizeof(sv): " << sizeof(sv) << " 字节\n";
39. std::cout << "└─────────────────────────────────────────┘\n";
40. }
42. /**
43. * @brief 【典型场景1】字符串分割（零拷贝）
44. * @param str 要分割的字符串视图
45. * @param delimiter 分隔符
46. * @return 分割后的子串视图列表（不复制任何字符数据）
47. *
48. * @note 这是 string_view 最经典的用法之一
49. * 传统方式：会为每个子串分配内存并复制字符
50. * 本方式：只记录每个子串在原字符串中的位置和长度
51. */
52. std::vector<std::string_view> split(std::string_view str, char delimiter) {
53. std::vector<std::string_view> result;
54. size_t start = 0;
56. while (start < str.size()) {
57. // 查找下一个分隔符
58. size_t end = str.find(delimiter, start);
60. if (end == std::string_view::npos) {
61. // 最后一部分（或没有分隔符）
62. result.push_back(str.substr(start));
63. break;
64. }
66. // 添加子串视图（零拷贝！只记录位置和长度）
67. result.push_back(str.substr(start, end - start));
68. start = end + 1;
69. }
71. return result;
72. }
74. /**
75. * @brief 【典型场景2】去除首尾空格（非破坏性）
76. * @param str 需要处理的字符串视图
77. * @return 去除首尾空格后的新视图
78. *
79. * @note 不修改原字符串，不复制数据，只是调整视图的边界
80. * 时间复杂度 O(n)，但空间复杂度 O(1)
81. */
82. std::string_view trim(std::string_view str) {
83. // 移除前导空白字符（空格、制表符、换行等）
84. while (!str.empty() && std::isspace(static_cast<unsigned char>(str.front()))) {
85. str.remove_prefix(1); // 将视图起始位置右移1
86. }
88. // 移除尾随空白字符
89. while (!str.empty() && std::isspace(static_cast<unsigned char>(str.back()))) {
90. str.remove_suffix(1); // 将视图结束位置左移1
91. }
93. return str;
94. }
96. /**
97. * @brief 【典型场景3】检查字符串前缀
98. * @param str 待检查的字符串
99. * @param prefix 可能的前缀
100. * @return 是否是前缀
101. */
102. bool starts_with(std::string_view str, std::string_view prefix) {
103. // 首先确保原字符串长度足够
104. if (str.size() < prefix.size()) {
105. return false;
106. }
107. // substr 是 O(1) 操作，不会复制数据
108. return str.substr(0, prefix.size()) == prefix;
109. }
111. /**
112. * @brief 【典型场景4】检查字符串后缀
113. * @param str 待检查的字符串
114. * @param suffix 可能的后缀
115. * @return 是否是后缀
116. */
117. bool ends_with(std::string_view str, std::string_view suffix) {
118. if (str.size() < suffix.size()) {
119. return false;
120. }
121. // 从尾部取子串进行对比，仍然是 O(1)
122. return str.substr(str.size() - suffix.size()) == suffix;
123. }
125. /**
126. * @brief 【典型场景5】大小写不敏感的比较
127. * @param a 字符串A
128. * @param b 字符串B
129. * @return 是否相等（忽略大小写）
130. */
131. bool iequals(std::string_view a, std::string_view b) {
132. if (a.size() != b.size()) {
133. return false;
134. }
136. // 双参数 lambda：比较两个字符是否相等（忽略大小写）
137. auto char_iequal = [](char c1, char c2) {
138. return std::tolower(static_cast<unsigned char>(c1)) ==
139. std::tolower(static_cast<unsigned char>(c2));
140. };
142. return std::equal(a.begin(), a.end(), b.begin(), char_iequal);
143. }
145. /**
146. * @brief 【典型场景6】提取文件扩展名
147. * @param filename 文件名
148. * @return 扩展名视图（不含点号）
149. */
150. std::string_view get_extension(std::string_view filename) {
151. // 查找最后一个点号
152. size_t dot_pos = filename.rfind('.');
154. if (dot_pos == std::string_view::npos) {
155. return {}; // 没有扩展名，返回空视图
156. }
158. // 返回点号之后的部分（零拷贝）
159. return filename.substr(dot_pos + 1);
160. }
162. /**
163. * @brief 【典型场景7】解析键值对
164. * @param kv_pair 格式为 "key=value" 的字符串
165. * @param key 输出参数：存储键的视图
166. * @param value 输出参数：存储值的视图
167. * @return 是否解析成功
168. */
169. bool parse_key_value(std::string_view kv_pair, std::string_view& key, std::string_view& value) {
170. size_t eq_pos = kv_pair.find('=');
172. if (eq_pos == std::string_view::npos) {
173. return false;
174. }
176. // 直接使用视图，不复制数据
177. key = trim(kv_pair.substr(0, eq_pos));
178. value = trim(kv_pair.substr(eq_pos + 1));
180. return !key.empty(); // 键不能为空
181. }
183. /**
184. * @brief 【典型场景8】灵活的函数参数
185. * @param data 可以接受任何字符串类型（字面量、std::string、C字符串）
186. * @return 字符串长度
187. *
188. * @note 使用 string_view 作为函数参数是最佳实践：
189. * 1. 不需要重载多个版本
190. * 2. 避免不必要的字符串拷贝
191. * 3. 调用者无需修改代码
192. */
193. size_t get_length(std::string_view data) {
194. // 这里只读取，不修改，完美发挥 string_view 的优势
195. return data.size();
196. }
198. // ==================== 主函数 ====================
200. int main() {
201. std::cout << "\n";
202. std::cout << "╔══════════════════════════════════════════════════════════════╗\n";
203. std::cout << "║ std::string_view 核心优势与典型场景演示 ║\n";
204. std::cout << "╚══════════════════════════════════════════════════════════════╝\n";
206. // ==================== 一、核心优势演示 ====================
208. std::cout << "\n【一、核心优势】\n";
209. std::cout << "─────────────────────────────────────────────────────────────\n";
211. // 优势1：极轻量（只占16字节）
212. std::cout << "\n✓ 优势1：轻量级（仅16字节）\n";
213. std::cout << " sizeof(std::string_view) = " << sizeof(std::string_view) << " 字节\n";
214. std::cout << " sizeof(std::string) = " << sizeof(std::string) << " 字节\n";
216. // 优势2：零拷贝构造
217. std::cout << "\n✓ 优势2：零拷贝构造\n";
218. std::string original = "这是一个很长的字符串，构造视图时不会复制任何字符数据";
219. std::string_view view = original; // 只复制指针和长度，不复制字符
220. std::cout << " 原字符串地址: " << (void*)original.data() << "\n";
221. std::cout << " 视图存储地址: " << (void*)view.data() << " (指向同一块内存)\n";
223. // 优势3：零拷贝子串
224. std::cout << "\n✓ 优势3：零拷贝子串操作\n";
225. std::string_view text = "The quick brown fox jumps over the lazy dog";
226. std::string_view sub = text.substr(10, 9); // "brown fox"
227. std::cout << " 原字符串: '" << text << "'\n";
228. std::cout << " 子串视图: '" << sub << "'\n";
229. std::cout << " 地址比较: 原:" << (void*)text.data()
230. << " vs 子:" << (void*)sub.data() << " (相同)\n";
231. std::cout << " 说明: substr 只记录了新的起始位置，没有复制数据\n";
233. // ==================== 二、典型应用场景 ====================
235. std::cout << "\n【二、典型应用场景】\n";
236. std::cout << "─────────────────────────────────────────────────────────────\n";
238. // 场景1：字符串分割
239. std::cout << "\n✓ 场景1：高效字符串分割\n";
240. std::string csv = "apple,banana,cherry,date,elderberry";
241. std::cout << " CSV 数据: " << csv << "\n";
243. auto fruits = split(csv, ',');
244. std::cout << " 分割结果（零拷贝视图）: ";
245. for (size_t i = 0; i < fruits.size(); ++i) {
246. std::cout << "'" << fruits[i] << "'";
247. if (i < fruits.size() - 1) std::cout << ", ";
248. }
249. std::cout << "\n";
250. std::cout << " 注意：所有子串视图都直接指向原字符串内存\n";
252. // 场景2：去除首尾空格
253. std::cout << "\n✓ 场景2：非破坏性空格去除\n";
254. std::string messy = " \t Hello, World! \n\r";
255. std::string_view trimmed = trim(messy);
256. std::cout << " 原字符串: '" << messy << "'\n";
257. std::cout << " 去除空格: '" << trimmed << "'\n";
258. std::cout << " 原字符串未被修改: '" << messy << "'\n";
260. // 场景3：前缀/后缀检查
261. std::cout << "\n✓ 场景3：高效前缀/后缀检查\n";
262. std::string filename = "document.pdf";
263. std::string_view fv = filename;
264. std::cout << " 文件名: " << fv << "\n";
265. std::cout << " 以 'doc' 开头? " << (starts_with(fv, "doc") ? "✓ 是" : "✗ 否") << "\n";
266. std::cout << " 以 '.pdf' 结尾? " << (ends_with(fv, ".pdf") ? "✓ 是" : "✗ 否") << "\n";
268. // 场景4：文件扩展名提取
269. std::cout << "\n✓ 场景4：文件扩展名提取\n";
270. std::vector<std::string> files = { "image.jpg", "document.pdf", "script.py", "Makefile" };
271. for (const auto& file : files) {
272. std::string_view ext = get_extension(file);
273. std::cout << " " << file << " → 扩展名: " << (ext.empty() ? "(无)" : ext.data()) << "\n";
274. }
276. // 场景5：解析键值对
277. std::cout << "\n✓ 场景5：解析键值对\n";
278. std::vector<std::string> kv_strings = {
279. "name=John Doe",
280. " age = 25 ",
281. "email=john@example.com"
282. };
284. for (const auto& kv : kv_strings) {
285. std::string_view key, value;
286. if (parse_key_value(kv, key, value)) {
287. std::cout << " 解析: |" << key << "| → |" << value << "|\n";
288. }
289. }
291. // 场景6：大小写不敏感比较
292. std::cout << "\n✓ 场景6：大小写不敏感比较\n";
293. std::string_view hello1 = "Hello";
294. std::string_view hello2 = "HELLO";
295. std::string_view hello3 = "World";
296. std::cout << " 'Hello' vs 'HELLO': " << (iequals(hello1, hello2) ? "相等" : "不等") << "\n";
297. std::cout << " 'Hello' vs 'World': " << (iequals(hello1, hello3) ? "相等" : "不等") << "\n";
299. // 场景7：灵活的字符串类型兼容性
300. std::cout << "\n✓ 场景7：统一处理多种字符串类型\n";
301. const char* c_str = "C字符串";
302. std::string cpp_str = "C++字符串";
303. std::string_view view_str = "字符串视图";
305. // 同一个函数可以接受所有类型
306. std::cout << " C字符串长度: " << get_length(c_str) << "\n";
307. std::cout << " C++字符串长度: " << get_length(cpp_str) << "\n";
308. std::cout << " 字符串视图长度: " << get_length(view_str) << "\n";
310. // ==================== 三、输出格式演示 ====================
312. std::cout << "\n【三、多种遍历方式】\n";
313. std::cout << "─────────────────────────────────────────────────────────────\n";
315. std::string_view demo = "C++17";
316. print_info(demo, "遍历示例");
318. std::cout << "\n 遍历方式1（下标）: ";
319. for (size_t i = 0; i < demo.size(); ++i) {
320. std::cout << demo[i] << " ";
321. }
323. std::cout << "\n 遍历方式2（范围for）: ";
324. for (char ch : demo) {
325. std::cout << ch << " ";
326. }
328. std::cout << "\n 遍历方式3（迭代器）: ";
329. for (auto it = demo.begin(); it != demo.end(); ++it) {
330. std::cout << *it << " ";
331. }
332. std::cout << "\n";
334. std::cout << "\n═══════════════════════════════════════════════════════════════\n";
335. std::cout << "✅ 演示完成！string_view 的核心优势：\n";
336. std::cout << " • 零拷贝（不分配内存）\n";
337. std::cout << " • 轻量级（只占16字节）\n";
338. std::cout << " • 兼容多种字符串类型\n";
339. std::cout << " • 高效子串操作\n";
340. std::cout << " • 作为函数参数的最佳实践\n";
341. std::cout << "═══════════════════════════════════════════════════════════════\n";
343. return 0;
344. }

复制代码

2. ╔══════════════════════════════════════════════════════════════╗
3. ║ std::string_view 核心优势与典型场景演示 ║
4. ╚══════════════════════════════════════════════════════════════╝
6. 【一、核心优势】
7. ─────────────────────────────────────────────────────────────
9. ✓ 优势1：轻量级（仅16字节）
10. sizeof(std::string_view) = 16 字节
11. sizeof(std::string) = 40 字节
13. ✓ 优势2：零拷贝构造
14. 原字符串地址: 000001E96A6DBE30
15. 视图存储地址: 000001E96A6DBE30 (指向同一块内存)
17. ✓ 优势3：零拷贝子串操作
18. 原字符串: 'The quick brown fox jumps over the lazy dog'
19. 子串视图: 'brown fox'
20. 地址比较: 原:00007FF6F8803950 vs 子:00007FF6F880395A (相同)
21. 说明: substr 只记录了新的起始位置，没有复制数据
23. 【二、典型应用场景】
24. ─────────────────────────────────────────────────────────────
26. ✓ 场景1：高效字符串分割
27. CSV 数据: apple,banana,cherry,date,elderberry
28. 分割结果（零拷贝视图）: 'apple', 'banana', 'cherry', 'date', 'elderberry'
29. 注意：所有子串视图都直接指向原字符串内存
31. ✓ 场景2：非破坏性空格去除
32. 原字符串: ' Hello, World!
33. '
34. 去除空格: 'Hello, World!'
35. 原字符串未被修改: ' Hello, World!
36. '
38. ✓ 场景3：高效前缀/后缀检查
39. 文件名: document.pdf
40. 以 'doc' 开头? ✓ 是
41. 以 '.pdf' 结尾? ✓ 是
43. ✓ 场景4：文件扩展名提取
44. image.jpg → 扩展名: jpg
45. document.pdf → 扩展名: pdf
46. script.py → 扩展名: py
47. Makefile → 扩展名: (无)
49. ✓ 场景5：解析键值对
50. 解析: |name| → |John Doe|
51. 解析: |age| → |25|
52. 解析: |email| → |john@example.com|
54. ✓ 场景6：大小写不敏感比较
55. 'Hello' vs 'HELLO': 相等
56. 'Hello' vs 'World': 不等
58. ✓ 场景7：统一处理多种字符串类型
59. C字符串长度: 10
60. C++字符串长度: 12
61. 字符串视图长度: 15
63. 【三、多种遍历方式】
64. ─────────────────────────────────────────────────────────────
66. ┌─────────────────────────────────────────┐
67. │ 遍历示例
68. ├─────────────────────────────────────────┤
69. │ 内容: 'C++17'
70. │ 长度: 5 字符
71. │ 是否为空: 否
72. │ sizeof(sv): 16 字节
73. └─────────────────────────────────────────┘
75. 遍历方式1（下标）: C + + 1 7
76. 遍历方式2（范围for）: C + + 1 7
77. 遍历方式3（迭代器）: C + + 1 7
79. ═══════════════════════════════════════════════════════════════
80. ✅ 演示完成！string_view 的核心优势：
81. • 零拷贝（不分配内存）
82. • 轻量级（只占16字节）
83. • 兼容多种字符串类型
84. • 高效子串操作
85. • 作为函数参数的最佳实践
86. ═══════════════════════════════════════════════════════════════
88. E:\myLearn\StringView\x64\Debug\StringView.exe (进程 25764)已退出，代码为 0 (0x0)。
89. 按任意键关闭此窗口. . .

复制代码

---

⚡ 性能对比测试

1. /**
2. * @file string_view_performance_demo.cpp
3. * @brief std::string_view 性能对比测试
4. * @author Code Reviewer
5. * @date 2026-05-12
6. *
7. * @details 本文件通过基准测试对比 string_view 和传统 string 的性能差异：
8. * 1. 构造性能对比（拷贝 vs 视图）
9. * 2. 子串操作性能对比
10. * 3. 函数参数传递性能对比
11. * 4. 字符串分割性能对比
12. * 5. 大规模数据处理测试
13. *
14. * 编译运行：
15. * g++ -std=c++17 -O2 string_view_performance_demo.cpp -o perf_demo
16. * ./perf_demo
17. */
19. #include <iostream>
20. #include <string>
21. #include <string_view>
22. #include <vector>
23. #include <chrono>
24. #include <algorithm>
25. #include <numeric>
26. #include <iomanip>
28. /**
29. * @brief 高性能计时器类
30. * @details 用于精确测量代码块执行时间
31. */
32. class Timer {
33. private:
34. std::chrono::high_resolution_clock::time_point start_time;
35. std::string name;
37. public:
38. /**
39. * @brief 构造函数，开始计时
40. * @param test_name 测试名称
41. */
42. Timer(const std::string& test_name) : name(test_name) {
43. start_time = std::chrono::high_resolution_clock::now();
44. }
46. /**
47. * @brief 析构函数，自动输出耗时
48. */
49. ~Timer() {
50. auto end_time = std::chrono::high_resolution_clock::now();
51. auto duration = std::chrono::duration_cast<std::chrono::microseconds>(end_time - start_time);
52. std::cout << " ⏱️ " << name << ": " << std::setw(8) << duration.count() << " 微秒\n";
53. }
55. /**
56. * @brief 手动获取耗时（不结束计时）
57. */
58. long long elapsed() const {
59. auto now = std::chrono::high_resolution_clock::now();
60. return std::chrono::duration_cast<std::chrono::microseconds>(now - start_time).count();
61. }
62. };
64. /**
65. * @brief 使用 std::string 进行字符串分割（传统方式）
66. * @param str 字符串
67. * @param delimiter 分隔符
68. * @return 分割后的子串列表（每个子串都有独立的内存）
69. *
70. * @note 这种方式会为每个子串分配内存并复制字符数据
71. */
72. std::vector<std::string> split_string(const std::string& str, char delimiter) {
73. std::vector<std::string> result;
74. size_t start = 0;
76. while (start < str.size()) {
77. size_t end = str.find(delimiter, start);
78. if (end == std::string::npos) {
79. result.push_back(str.substr(start)); // 复制数据
80. break;
81. }
82. result.push_back(str.substr(start, end - start)); // 复制数据
83. start = end + 1;
84. }
85. return result;
86. }
88. /**
89. * @brief 使用 std::string_view 进行字符串分割（现代方式）
90. * @param str 字符串视图
91. * @param delimiter 分隔符
92. * @return 分割后的子串视图列表（零拷贝）
93. *
94. * @note 这种方式不复制任何字符数据，只记录位置和长度
95. */
96. std::vector<std::string_view> split_string_view(std::string_view str, char delimiter) {
97. std::vector<std::string_view> result;
98. size_t start = 0;
100. while (start < str.size()) {
101. size_t end = str.find(delimiter, start);
102. if (end == std::string_view::npos) {
103. result.push_back(str.substr(start)); // 零拷贝
104. break;
105. }
106. result.push_back(str.substr(start, end - start)); // 零拷贝
107. start = end + 1;
108. }
109. return result;
110. }
112. /**
113. * @brief 性能测试1：构造性能对比
114. * @param iterations 迭代次数
115. *
116. * @details 对比创建 1000 个字符串子串的耗时差异
117. * 字符串视图的构造只是复制指针，远快于实际复制字符数据
118. */
119. void test_construction_performance(int iterations = 1000) {
120. std::cout << "\n┌─────────────────────────────────────────────────────────────┐\n";
121. std::cout << "│ 测试1：构造性能对比（创建 " << iterations << " 个子串） │\n";
122. std::cout << "└─────────────────────────────────────────────────────────────┘\n";
124. // 准备一个长字符串
125. std::string long_string(10000, 'A');
126. for (int i = 0; i < 100; ++i) {
127. long_string[i * 100] = ','; // 添加分隔符
128. }
130. // 测试 std::string 构造（会复制字符）
131. {
132. Timer timer("std::string 构造（复制 " + std::to_string(iterations) + " 次）");
133. for (int i = 0; i < iterations; ++i) {
134. std::string copy = long_string; // 复制整个字符串
135. (void)copy;
136. }
137. }
139. // 测试 std::string_view 构造（只复制指针）
140. {
141. Timer timer("std::string_view 构造（" + std::to_string(iterations) + " 次）");
142. for (int i = 0; i < iterations; ++i) {
143. std::string_view view = long_string; // 只复制16字节
144. (void)view;
145. }
146. }
147. }
149. /**
150. * @brief 性能测试2：子串操作性能对比
151. * @param iterations 迭代次数
152. *
153. * @details 对比提取 10000 个子串的耗时
154. * string::substr 会复制数据，string_view::substr 只调整视图边界
155. */
156. void test_substr_performance(int iterations = 10000) {
157. std::cout << "\n┌─────────────────────────────────────────────────────────────┐\n";
158. std::cout << "│ 测试2：子串操作性能对比（提取 " << iterations << " 个子串） │\n";
159. std::cout << "└─────────────────────────────────────────────────────────────┘\n";
161. std::string data = "https://www.example.com/very/long/path/to/resource";
163. // 测试 std::string::substr（复制数据）
164. {
165. Timer timer("std::string::substr（复制数据）");
166. for (int i = 0; i < iterations; ++i) {
167. std::string sub = data.substr(8, 10); // 复制 "www.exampl"
168. (void)sub;
169. }
170. }
172. // 测试 std::string_view::substr（零拷贝）
173. {
174. Timer timer("std::string_view::substr（零拷贝）");
175. std::string_view view = data;
176. for (int i = 0; i < iterations; ++i) {
177. std::string_view sub = view.substr(8, 10); // 只调整边界
178. (void)sub;
179. }
180. }
181. }
183. /**
184. * @brief 测试3：字符串分割性能对比
185. * @param iterations 重复测试次数
186. *
187. * @details 对比传统方式和视图方式在字符串分割上的性能差异
188. * 处理 1MB 的 CSV 数据，分割成约 200,000 个字段
189. */
190. void test_split_performance(int iterations = 10) {
191. std::cout << "\n┌─────────────────────────────────────────────────────────────┐\n";
192. std::cout << "│ 测试3：字符串分割性能对比（1MB CSV 数据，重复 " << iterations << " 次） │\n";
193. std::cout << "└─────────────────────────────────────────────────────────────┘\n";
195. // 生成测试数据：1MB 的 CSV 格式字符串
196. std::string csv_data;
197. csv_data.reserve(1024 * 1024);
198. for (int i = 0; i < 100000; ++i) {
199. csv_data += "field" + std::to_string(i) + ",";
200. }
201. csv_data.back() = '\n'; // 替换最后一个逗号
203. // 测试 std::string 分割（会复制每个字段）
204. {
205. long long total_time = 0;
206. for (int i = 0; i < iterations; ++i) {
207. auto start = std::chrono::high_resolution_clock::now();
208. auto result = split_string(csv_data, ',');
209. auto end = std::chrono::high_resolution_clock::now();
210. total_time += std::chrono::duration_cast<std::chrono::microseconds>(end - start).count();
212. // 验证结果
213. if (i == 0) {
214. std::cout << " 📊 std::string 分割: " << result.size() << " 个字段\n";
215. }
216. }
217. std::cout << " ⏱️ std::string 分割（平均）: "
218. << std::setw(8) << total_time / iterations << " 微秒\n";
219. }
221. // 测试 std::string_view 分割（零拷贝）
222. {
223. long long total_time = 0;
224. for (int i = 0; i < iterations; ++i) {
225. auto start = std::chrono::high_resolution_clock::now();
226. auto result = split_string_view(csv_data, ',');
227. auto end = std::chrono::high_resolution_clock::now();
228. total_time += std::chrono::duration_cast<std::chrono::microseconds>(end - start).count();
230. if (i == 0) {
231. std::cout << " 📊 string_view 分割: " << result.size() << " 个视图\n";
232. }
233. }
234. std::cout << " ⏱️ string_view 分割（平均）: "
235. << std::setw(8) << total_time / iterations << " 微秒\n";
236. }
237. }
239. /**
240. * @brief 测试4：函数参数传递性能对比
241. * @param iterations 迭代次数
242. *
243. * @details 对比传递 string 引用 vs string_view 的性能
244. * string_view 更轻量，且不会引起不必要的分配
245. */
246. void test_parameter_passing(int iterations = 1000000) {
247. std::cout << "\n┌─────────────────────────────────────────────────────────────┐\n";
248. std::cout << "│ 测试4：函数参数传递性能对比（调用 " << iterations << " 次） │\n";
249. std::cout << "└─────────────────────────────────────────────────────────────┘\n";
251. std::string data = "这是一个测试字符串，用于性能对比";
253. // 定义测试函数
254. auto process_by_const_ref = [](const std::string& s) -> size_t {
255. return s.size();
256. };
258. auto process_by_string_view = [](std::string_view sv) -> size_t {
259. return sv.size();
260. };
262. // 测试 const std::string& 传递
263. {
264. Timer timer("const std::string& 传递");
265. size_t sum = 0;
266. for (int i = 0; i < iterations; ++i) {
267. sum += process_by_const_ref(data);
268. }
269. (void)sum;
270. }
272. // 测试 std::string_view 传递
273. {
274. Timer timer("std::string_view 传递");
275. size_t sum = 0;
276. for (int i = 0; i < iterations; ++i) {
277. sum += process_by_string_view(data);
278. }
279. (void)sum;
280. }
282. // 测试从字面量传递的情况（string_view 优势更明显）
283. {
284. Timer timer("string_view + 字面量（避免临时 string）");
285. size_t sum = 0;
286. for (int i = 0; i < iterations; ++i) {
287. sum += process_by_string_view("Hello, World!");
288. }
289. (void)sum;
290. }
291. }
293. /**
294. * @brief 测试5：大规模数据处理性能对比
295. * @param data_size_mb 数据大小（MB）
296. *
297. * @details 处理 10MB 的日志数据，模拟实际场景
298. * 统计以 'ERROR' 开头的行数
299. */
300. void test_large_data_processing(int data_size_mb = 10) {
301. std::cout << "\n┌─────────────────────────────────────────────────────────────┐\n";
302. std::cout << "│ 测试5：大规模数据处理（" << data_size_mb << " MB 日志数据） │\n";
303. std::cout << "└─────────────────────────────────────────────────────────────┘\n";
305. // 生成测试日志数据
306. std::string log_data;
307. log_data.reserve(data_size_mb * 1024 * 1024);
309. for (int i = 0; i < 500000; ++i) {
310. if (i % 100 == 0) {
311. log_data += "ERROR: Something went wrong at step " + std::to_string(i) + "\n";
312. } else {
313. log_data += "INFO: Processing step " + std::to_string(i) + "\n";
314. }
315. }
317. // 使用 std::string 的方式（复制并分割）
318. {
319. Timer timer("std::string 方式（复制行数据）");
320. int error_count = 0;
321. size_t start = 0;
322. std::string data_copy = log_data; // 先复制整个数据
324. while (start < data_copy.size()) {
325. size_t end = data_copy.find('\n', start);
326. if (end == std::string::npos) break;
328. std::string line = data_copy.substr(start, end - start); // 复制每一行
329. if (line.size() >= 5 && line.substr(0, 5) == "ERROR") {
330. ++error_count;
331. }
332. start = end + 1;
333. }
334. std::cout << " 📊 找到 " << error_count << " 条 ERROR 日志\n";
335. }
337. // 使用 std::string_view 的方式（只读视图）
338. {
339. Timer timer("string_view 方式（零拷贝）");
340. int error_count = 0;
341. size_t start = 0;
342. std::string_view view = log_data; // 不复制
344. while (start < view.size()) {
345. size_t end = view.find('\n', start);
346. if (end == std::string_view::npos) break;
348. std::string_view line = view.substr(start, end - start); // 零拷贝视图
349. if (line.size() >= 5 && line.substr(0, 5) == "ERROR") {
350. ++error_count;
351. }
352. start = end + 1;
353. }
354. std::cout << " 📊 找到 " << error_count << " 条 ERROR 日志\n";
355. }
356. }
358. /**
359. * @brief 显示速度对比总结
360. */
361. void show_summary() {
362. std::cout << "\n\n╔═══════════════════════════════════════════════════════════════╗\n";
363. std::cout << "║ 性能测试总结 ║\n";
364. std::cout << "╠═══════════════════════════════════════════════════════════════╣\n";
365. std::cout << "║ std::string_view 的核心性能优势： ║\n";
366. std::cout << "║ ║\n";
367. std::cout << "║ 1. 零拷贝构造 → 只复制16字节，与字符串长度无关 ║\n";
368. std::cout << "║ 2. 零拷贝子串 → O(1) 时间，不随子串长度增加 ║\n";
369. std::cout << "║ 3. 减少内存分配 → 避免频繁的 malloc/free ║\n";
370. std::cout << "║ 4. 更好的缓存局部性 → 数据在原位置，不产生内存碎片 ║\n";
371. std::cout << "║ 5. 无额外内存开销 → 适合嵌入式/高性能环境 ║\n";
372. std::cout << "╠═══════════════════════════════════════════════════════════════╣\n";
373. std::cout << "║ 适用场景： ║\n";
374. std::cout << "║ • 函数参数（避免不必要的拷贝） ║\n";
375. std::cout << "║ • 字符串解析（配置文件、日志、网络协议） ║\n";
376. std::cout << "║ • 大规模文本处理（日志分析、数据清洗） ║\n";
377. std::cout << "║ • 只读访问场景（查找、比较、过滤） ║\n";
378. std::cout << "╠═══════════════════════════════════════════════════════════════╣\n";
379. std::cout << "║ 注意事项： ║\n";
380. std::cout << "║ • 不保证以 '\\0' 结尾，使用 .data() 需谨慎 ║\n";
381. std::cout << "║ • 不拥有数据，需确保底层数据生命周期更长 ║\n";
382. std::cout << "║ • 修改原字符串会使视图失效 ║\n";
383. std::cout << "╚═══════════════════════════════════════════════════════════════╝\n";
384. }
386. // ==================== 主函数 ====================
388. int main() {
389. std::cout << "\n";
390. std::cout << "╔═══════════════════════════════════════════════════════════════╗\n";
391. std::cout << "║ std::string_view 性能对比测试 ║\n";
392. std::cout << "║ 编译优化: -O2 ║\n";
393. std::cout << "╚═══════════════════════════════════════════════════════════════╝\n";
395. // 运行所有性能测试
396. test_construction_performance(1000);
397. test_substr_performance(10000);
398. test_split_performance(10);
399. test_parameter_passing(1000000);
400. test_large_data_processing(5);
402. // 显示总结
403. show_summary();
405. return 0;
406. }

复制代码

2. ╔═══════════════════════════════════════════════════════════════╗
3. ║ std::string_view 性能对比测试 ║
4. ║ 编译优化: -O2 ║
5. ╚═══════════════════════════════════════════════════════════════╝
7. ┌─────────────────────────────────────────────────────────────┐
8. │ 测试1：构造性能对比（创建 1000 个子串） │
9. └─────────────────────────────────────────────────────────────┘
10. ⏱️ std::string 构造（复制 1000 次）: 813 微秒
11. ⏱️ std::string_view 构造（1000 次）: 16 微秒
13. ┌─────────────────────────────────────────────────────────────┐
14. │ 测试2：子串操作性能对比（提取 10000 个子串） │
15. └─────────────────────────────────────────────────────────────┘
16. ⏱️ std::string::substr（复制数据）: 3824 微秒
17. ⏱️ std::string_view::substr（零拷贝）: 342 微秒
19. ┌─────────────────────────────────────────────────────────────┐
20. │ 测试3：字符串分割性能对比（1MB CSV 数据，重复 10 次） │
21. └─────────────────────────────────────────────────────────────┘
22. 📊 std::string 分割: 100000 个字段
23. ⏱️ std::string 分割（平均）: 188841 微秒
24. 📊 string_view 分割: 100000 个视图
25. ⏱️ string_view 分割（平均）: 11620 微秒
27. ┌─────────────────────────────────────────────────────────────┐
28. │ 测试4：函数参数传递性能对比（调用 1000000 次） │
29. └─────────────────────────────────────────────────────────────┘
30. ⏱️ const std::string& 传递: 3061 微秒
31. ⏱️ std::string_view 传递: 18145 微秒
32. ⏱️ string_view + 字面量（避免临时 string）: 13493 微秒
34. ┌─────────────────────────────────────────────────────────────┐
35. │ 测试5：大规模数据处理（5 MB 日志数据） │
36. └─────────────────────────────────────────────────────────────┘
37. 📊 找到 5000 条 ERROR 日志
38. ⏱️ std::string 方式（复制行数据）: 589907 微秒
39. 📊 找到 5000 条 ERROR 日志
40. ⏱️ string_view 方式（零拷贝）: 54217 微秒
43. ╔═══════════════════════════════════════════════════════════════╗
44. ║ 性能测试总结 ║
45. ╠═══════════════════════════════════════════════════════════════╣
46. ║ std::string_view 的核心性能优势： ║
47. ║ ║
48. ║ 1. 零拷贝构造 → 只复制16字节，与字符串长度无关 ║
49. ║ 2. 零拷贝子串 → O(1) 时间，不随子串长度增加 ║
50. ║ 3. 减少内存分配 → 避免频繁的 malloc/free ║
51. ║ 4. 更好的缓存局部性 → 数据在原位置，不产生内存碎片 ║
52. ║ 5. 无额外内存开销 → 适合嵌入式/高性能环境 ║
53. ╠═══════════════════════════════════════════════════════════════╣
54. ║ 适用场景： ║
55. ║ • 函数参数（避免不必要的拷贝） ║
56. ║ • 字符串解析（配置文件、日志、网络协议） ║
57. ║ • 大规模文本处理（日志分析、数据清洗） ║
58. ║ • 只读访问场景（查找、比较、过滤） ║
59. ╠═══════════════════════════════════════════════════════════════╣
60. ║ 注意事项： ║
61. ║ • 不保证以 '\0' 结尾，使用 .data() 需谨慎 ║
62. ║ • 不拥有数据，需确保底层数据生命周期更长 ║
63. ║ • 修改原字符串会使视图失效 ║
64. ╚═══════════════════════════════════════════════════════════════╝
66. E:\myLearn\StringView\x64\Debug\StringView.exe (进程 24704)已退出，代码为 0 (0x0)。
67. 按任意键关闭此窗口. . .

复制代码

---

⚠️ 注意事项

• 生命周期管理：std::string_view 不管理底层字符串的生命周期，string_view 对象的生命周期不能超过指向的字符串。如果你需要传递一个 string_view，必须确保它指向的字符串在整个使用期间都有效。
• \0 结尾问题：string_view 不一定以 \0 结尾，如果你需要传递给一个以 \0 结尾的 C API（如 fopen），必须确保它是 \0 结尾的，或者手动创建一个以 \0 结尾的副本（例如使用 std::string(sv)）。
• 底层字符串修改：如果底层字符串被修改或销毁，string_view 会变成 “悬空” 状态，访问它会导致未定义行为。

1. #define _CRT_SECURE_NO_WARNINGS
2. /**
3. * @file string_view_lifetime_demo.cpp
4. * @brief std::string_view 生命周期管理、\0结尾、底层修改 三大注意事项验证
5. * @author Code Reviewer
6. * @date 2026-05-12
7. *
8. * @details 本文件演示 std::string_view 的三个关键陷阱：
9. * 1. 生命周期管理：string_view 不拥有数据，不能比源字符串活得久
10. * 2. \0 结尾问题：string_view 不一定以 \0 结尾，传给 C API 需小心
11. * 3. 底层字符串修改：修改原字符串会使 string_view 失效
12. *
13. * 编译运行：
14. * g++ -std=c++17 -O2 string_view_lifetime_demo.cpp -o demo
15. * ./demo
16. */
18. #include <iostream>
19. #include <string>
20. #include <string_view>
21. #include <vector>
22. #include <cstring>
23. #include <fstream>
25. // ==================== 辅助函数 ====================
27. /**
28. * @brief 安全打印 string_view（带边界标识）
29. */
30. void safe_print(std::string_view sv, const std::string& title = "") {
31. if (!title.empty()) {
32. std::cout << "\n【" << title << "】\n";
33. }
34. std::cout << " 内容: '" << sv << "'\n";
35. std::cout << " 长度: " << sv.size() << "\n";
36. std::cout << " 是否以\\0结尾: " << (sv.data()[sv.size()] == '\0' ? "是" : "否") << "\n";
37. }
39. // ==================== 注意事项1：生命周期管理 ====================
41. /**
42. * @brief 危险示例：返回局部字符串的 string_view
43. * @return 悬空的 string_view（未定义行为）
44. *
45. * ⚠️ 这是典型的错误用法！
46. * 局部字符串在函数返回时被销毁，返回的 string_view 变成悬空引用。
47. */
48. std::string_view dangerous_return() {
49. std::string local = "这个字符串马上会被销毁";
50. std::string_view sv = local;
52. std::cout << " [函数内部] sv 有效: '" << sv << "'\n";
54. // ⚠️ 返回 sv，但 local 即将被销毁
55. return sv; // 危险！返回悬空引用
56. }
58. /**
59. * @brief 正确示例：返回拥有所有权的字符串
60. * @return 安全的 std::string
61. *
62. * ✅ 如果需要返回字符串，应该返回 std::string 而不是 string_view
63. */
64. std::string safe_return() {
65. std::string local = "这个字符串会安全返回";
66. return local; // 移动语义，高效且安全
67. }
69. /**
70. * @brief 正确示例：从已有数据创建 string_view
71. * @param data 生命周期足够长的数据
72. * @return 安全的 string_view
73. *
74. * ✅ string_view 只作为观察者，不拥有数据
75. */
76. std::string_view safe_parameter(const std::string& data) {
77. return data; // 安全：调用者保证 data 生命周期足够长
78. }
80. /**
81. * @brief 验证生命周期管理的正确与错误用法
82. */
83. void verify_lifetime() {
84. std::cout << "\n╔═══════════════════════════════════════════════════════════════╗\n";
85. std::cout << "║ 注意事项1：生命周期管理 ║\n";
86. std::cout << "║ string_view 不管理生命周期，不能比源字符串活得久 ║\n";
87. std::cout << "╚═══════════════════════════════════════════════════════════════╝\n";
89. // ✅ 正确用法1：string_view 生命周期在源字符串内
90. std::cout << "\n✅ 正确示例：生命周期内使用\n";
91. {
92. std::string data = "持久存在的字符串";
93. std::string_view view = data; // view 指向 data
94. std::cout << " view: '" << view << "'\n";
95. // data 和 view 都在作用域内，安全
96. std::cout << " → 安全：view 和 data 在同一作用域\n";
97. }
99. // ✅ 正确用法2：作为函数参数
100. std::cout << "\n✅ 正确示例：作为函数参数\n";
101. {
102. std::string data = "作为参数传递";
103. auto process = [](std::string_view sv) {
104. std::cout << " 函数内接收到: '" << sv << "'\n";
105. };
106. process(data); // 调用者保证 data 在函数执行期间有效
107. std::cout << " → 安全：调用者保证生命周期\n";
108. }
110. // ❌ 危险示例：返回局部字符串的视图
111. std::cout << "\n❌ 危险示例：返回局部变量的 view\n";
112. std::cout << " ⚠️ 下面的代码会触发未定义行为，已被注释\n";
113. // std::string_view dangling = dangerous_return(); // 未定义行为！
114. // std::cout << dangling << "\n"; // 可能崩溃或输出乱码
115. std::cout << " → 危险：view 指向已销毁的内存，访问会导致未定义行为\n";
117. // ✅ 正确示例：如果需要返回，返回 std::string
118. std::cout << "\n✅ 正确做法：需要返回时使用 std::string\n";
119. {
120. std::string result = safe_return();
121. std::cout << " 返回的字符串: '" << result << "'\n";
122. std::cout << " → 安全：返回拥有所有权的 std::string\n";
123. }
125. // 可视化生命周期问题
126. std::cout << "\n📊 生命周期图解：\n";
127. std::cout << " ┌─────────────────────────────────────────────────────────┐\n";
128. std::cout << " │ std::string data = "Hello"; // data 拥有内存 │\n";
129. std::cout << " │ std::string_view sv = data; // sv 指向 data │\n";
130. std::cout << " │ // data 和 sv 都在作用域内 // ✅ 安全 │\n";
131. std::cout << " │ } // data 被销毁 // ❌ sv 变成悬空 │\n";
132. std::cout << " └─────────────────────────────────────────────────────────┘\n";
133. }
135. // ==================== 注意事项2：\0 结尾问题 ====================
137. /**
138. * @brief 演示 string_view 不一定以 \0 结尾
139. *
140. * string_view 只存储指针和长度，不保证结尾有 null 终止符。
141. * 这对需要 \0 结尾的 C API（如 fopen, strcmp, printf %s）是危险的。
142. */
143. void verify_null_termination() {
144. std::cout << "\n\n╔═══════════════════════════════════════════════════════════════╗\n";
145. std::cout << "║ 注意事项2：\\0 结尾问题 ║\n";
146. std::cout << "║ string_view 不保证以 \\0 结尾 ║\n";
147. std::cout << "╚═══════════════════════════════════════════════════════════════╝\n";
149. // 情况1：从字符串字面量构造（有 \0 结尾）
150. std::cout << "\n📌 情况1：从字符串字面量构造\n";
151. std::string_view sv1 = "Hello";
152. safe_print(sv1, "字符串字面量");
153. std::cout << " 说明：字面量在编译期自动添加 \\0，所以有结尾符\n";
155. // 情况2：从 std::string 构造（有 \0 结尾，C++11 起保证）
156. std::cout << "\n📌 情况2：从 std::string 构造\n";
157. std::string str = "World";
158. std::string_view sv2 = str;
159. safe_print(sv2, "std::string");
160. std::cout << " 说明：std::string 保证 \\0 结尾（C++11 起）\n";
162. // 情况3：从子串构造（⚠️ 不一定有 \0 结尾！）
163. std::cout << "\n📌 情况3：从子串构造（⚠️ 危险场景）\n";
164. std::string long_str = "Hello, World!";
165. std::string_view sv3 = long_str.substr(0, 5); // 取 "Hello"
166. safe_print(sv3, "substr 子串");
167. std::cout << " ⚠️ 危险：substr 创建的视图不一定有 \\0 结尾！\n";
168. std::cout << " 📌 原因：substr 只调整指针和长度，不复制数据\n";
170. // 情况4：从字符数组的中间位置
171. std::cout << "\n📌 情况4：指向字符数组中间\n";
172. const char* cstr = "Programming";
173. std::string_view sv4(cstr + 3, 6); // 从索引3开始，取6个字符 → "grammi"
174. safe_print(sv4, "指向中间");
175. std::cout << " ⚠️ 危险：view.data()[view.size()] 访问越界！\n";
176. std::cout << " 📌 原因：view 指向字符串内部，后面没有 \\0\n";
178. // ❌ 危险操作：传给需要 \0 结尾的 C API
179. std::cout << "\n❌ 危险示例：传给 C API\n";
180. std::cout << " ⚠️ 以下代码会导致未定义行为，已被注释\n";
181. // std::string_view filename = "test.txt"; // 这个没问题
182. // FILE* f = fopen(filename.data(), "r"); // 危险！如果 view 没有 \0 结尾会崩溃
183. std::cout << " → 问题：C API 期望 \\0 结尾，但 view 不保证\n";
185. // ✅ 安全做法：需要 \0 结尾时转换为 std::string
186. std::cout << "\n✅ 安全做法：传给 C API 前转换为 std::string\n";
187. {
188. std::string_view sv = "temp/test.txt";
189. // 方式1：显式转换为 string
190. std::string filename(sv); // 会复制并添加 \0
191. std::cout << " 方式1：std::string(sv) → 会复制并添加 \\0\n";
193. // 方式2：临时构造（用于函数调用）
194. auto call_c_api = [](const char* path) {
195. std::cout << " 调用 C API，路径: " << path << "\n";
196. };
197. call_c_api(std::string(sv).c_str()); // 临时 string 保证 \0 结尾
198. std::cout << " 方式2：std::string(sv).c_str() → 适合单次调用\n";
199. }
201. // 检测 string_view 是否有 \0 结尾的工具函数
202. std::cout << "\n📊 检测 string_view 是否有 \\0 结尾：\n";
203. std::cout << " bool is_null_terminated(std::string_view sv) {\n";
204. std::cout << " return sv.data()[sv.size()] == '\\0';\n";
205. std::cout << " }\n";
206. std::cout << " ⚠️ 注意：即使检测为 false，访问也是未定义行为！\n";
207. }
209. // ==================== 注意事项3：底层字符串修改 ====================
211. /**
212. * @brief 演示底层字符串修改对 string_view 的影响
213. *
214. * string_view 只是观察者，不拥有数据。
215. * 如果底层字符串被修改或重新分配，string_view 会变成悬空状态。
216. */
217. void verify_underlying_modification() {
218. std::cout << "\n\n╔═══════════════════════════════════════════════════════════════╗\n";
219. std::cout << "║ 注意事项3：底层字符串修改 ║\n";
220. std::cout << "║ 修改原字符串会使 string_view 失效 ║\n";
221. std::cout << "╚═══════════════════════════════════════════════════════════════╝\n";
223. // 场景1：通过原字符串修改内容
224. std::cout << "\n📌 场景1：修改原字符串内容\n";
225. {
226. std::string data = "Original Data";
227. std::string_view view = data;
228. std::cout << " 初始 data: '" << data << "'\n";
229. std::cout << " 初始 view: '" << view << "'\n";
231. // 修改原字符串
232. data[0] = 'M';
233. data[1] = 'o';
234. data[2] = 'd';
236. std::cout << " 修改后 data: '" << data << "'\n";
237. std::cout << " 修改后 view: '" << view << "'\n";
238. std::cout << " → view 反映了修改（指向同一内存）\n";
239. std::cout << " ⚠️ 注意：这可能不是期望的行为！\n";
240. }
242. // 场景2：字符串重新分配（最危险！）
243. std::cout << "\n📌 场景2：字符串重新分配（悬空引用）\n";
244. {
245. std::string data = "Short string"; // SSO 可能不分配堆内存
246. // 强制使用堆内存
247. data = "This is a very long string that will definitely allocate heap memory";
248. std::string_view view = data;
249. std::cout << " 初始 view: '" << view << "'\n";
250. std::cout << " 原字符串地址: " << (void*)view.data() << "\n";
252. // ⚠️ 追加内容可能导致重新分配
253. data += " and some more data to trigger reallocation!";
255. std::cout << " ⚠️ 重新分配后 string_view 变成悬空！\n";
256. std::cout << " 新字符串地址: " << (void*)data.data() << "\n";
257. std::cout << " view 仍指向旧地址: " << (void*)view.data() << "\n";
258. // std::cout << " view: '" << view << "'\n"; // 未定义行为！
259. std::cout << " → 危险：访问悬空 view 会导致未定义行为\n";
260. }
262. // 场景3：字符串销毁
263. std::cout << "\n📌 场景3：字符串销毁（经典陷阱）\n";
264. {
265. std::string_view view;
266. {
267. std::string data = "临时数据";
268. view = data; // view 指向 data
269. std::cout << " 作用域内 view: '" << view << "'\n";
270. } // data 在这里被销毁
271. // std::cout << view << "\n"; // 未定义行为！
272. std::cout << " → data 已销毁，view 变成悬空引用\n";
273. std::cout << " ⚠️ 访问 view 会导致缓冲区溢出或崩溃\n";
274. }
276. // 场景4：字符数组被修改
277. std::cout << "\n📌 场景4：栈上字符数组被修改\n";
278. {
279. char buffer[] = "Initial value";
280. std::string_view view = buffer;
281. std::cout << " 初始 view: '" << view << "'\n";
283. // 修改原始数组
284. strcpy(buffer, "Modified!");
285. std::cout << " 修改后 view: '" << view << "'\n";
286. std::cout << " → view 反映了修改（指向同一内存）\n";
287. }
289. // 安全实践
290. std::cout << "\n✅ 安全实践：\n";
291. std::cout << " 1. 确保 string_view 不拥有数据，只作为临时观察者\n";
292. std::cout << " 2. 不要在 string_view 存活期间修改/重分配底层字符串\n";
293. std::cout << " 3. 如果需要长期保存，使用 std::string 而不是 string_view\n";
294. std::cout << " 4. 函数参数用 string_view，函数返回值用 string\n";
295. }
297. // ==================== 综合示例：正确使用 string_view ====================
299. /**
300. * @brief 展示 string_view 的正确使用模式
301. */
302. class LogParser {
303. private:
304. std::string log_data_; // 拥有数据
305. std::vector<std::string_view> lines_; // 视图，不拥有数据
307. public:
308. /**
309. * @brief 构造函数：接收数据并创建视图
310. * @param data 日志数据（会被复制）
311. */
312. explicit LogParser(const std::string& data) : log_data_(data) {
313. // 安全：log_data_ 拥有数据，lines_ 只是视图
314. size_t start = 0;
315. while (start < log_data_.size()) {
316. size_t end = log_data_.find('\n', start);
317. if (end == std::string::npos) {
318. lines_.push_back(std::string_view(log_data_.c_str() + start));
319. break;
320. }
321. lines_.push_back(std::string_view(log_data_.c_str() + start, end - start));
322. start = end + 1;
323. }
324. }
326. /**
327. * @brief 获取行数
328. */
329. size_t line_count() const { return lines_.size(); }
331. /**
332. * @brief 获取指定行（安全：数据生命周期由类保证）
333. */
334. std::string_view get_line(size_t index) const {
335. if (index >= lines_.size()) {
336. return {};
337. }
338. return lines_[index];
339. }
341. /**
342. * @brief 查找包含特定字符串的行
343. */
344. std::vector<std::string_view> find_lines(std::string_view keyword) const {
345. std::vector<std::string_view> result;
346. for (auto line : lines_) {
347. if (line.find(keyword) != std::string_view::npos) {
348. result.push_back(line);
349. }
350. }
351. return result;
352. }
353. };
355. /**
356. * @brief 演示综合示例
357. */
358. void demonstrate_best_practice() {
359. std::cout << "\n\n╔═══════════════════════════════════════════════════════════════╗\n";
360. std::cout << "║ 最佳实践示例：LogParser 类 ║\n";
361. std::cout << "║ 正确使用 string_view 管理生命周期 ║\n";
362. std::cout << "╚═══════════════════════════════════════════════════════════════╝\n";
364. // 创建测试数据
365. std::string log_data =
366. "[INFO] Application started\n"
367. "[ERROR] Failed to open config file\n"
368. "[WARN] Deprecated API used\n"
369. "[INFO] Connection established\n"
370. "[ERROR] Timeout occurred\n";
372. // LogParser 拥有数据，内部视图安全
373. LogParser parser(log_data);
375. std::cout << "\n📊 日志解析结果：\n";
376. std::cout << " 总行数: " << parser.line_count() << "\n";
378. std::cout << "\n 查找包含 '[ERROR]' 的行：\n";
379. auto error_lines = parser.find_lines("[ERROR]");
380. for (auto line : error_lines) {
381. std::cout << " • " << line << "\n";
382. }
384. std::cout << "\n ✅ 关键点：\n";
385. std::cout << " 1. LogParser 拥有 log_data_ 的所有权\n";
386. std::cout << " 2. lines_ 中的 string_view 指向 log_data_\n";
387. std::cout << " 3. 返回 string_view 是安全的（数据生命周期由类保证）\n";
388. std::cout << " 4. 不会发生悬空引用或内存泄漏\n";
389. }
391. // ==================== 主函数 ====================
393. int main() {
394. std::cout << "\n";
395. std::cout << "╔═══════════════════════════════════════════════════════════════╗\n";
396. std::cout << "║ std::string_view 三大注意事项验证程序 ║\n";
397. std::cout << "╚═══════════════════════════════════════════════════════════════╝\n";
399. // 运行所有验证
400. verify_lifetime();
401. verify_null_termination();
402. verify_underlying_modification();
403. demonstrate_best_practice();
405. // 最终总结
406. std::cout << "\n\n╔═══════════════════════════════════════════════════════════════╗\n";
407. std::cout << "║ 总结与检查清单 ║\n";
408. std::cout << "╠═══════════════════════════════════════════════════════════════╣\n";
409. std::cout << "║ □ 生命周期：确保 string_view 不超出源字符串的作用域 ║\n";
410. std::cout << "║ □ \\0 结尾：传给 C API 前确认或转换为 std::string ║\n";
411. std::cout << "║ □ 底层修改：view 存活期间不修改/重分配底层字符串 ║\n";
412. std::cout << "║ □ 返回值：需要返回时用 std::string，不要返回 string_view ║\n";
413. std::cout << "║ □ 参数：函数参数用 string_view（临时观察者） ║\n";
414. std::cout << "║ □ 成员：类成员用 std::string（拥有数据） ║\n";
415. std::cout << "╚═══════════════════════════════════════════════════════════════╝\n";
417. return 0;
418. }

复制代码

1. ╔═══════════════════════════════════════════════════════════════╗
2. ║ std::string_view 三大注意事项验证程序 ║
3. ╚═══════════════════════════════════════════════════════════════╝
5. ╔═══════════════════════════════════════════════════════════════╗
6. ║ 注意事项1：生命周期管理 ║
7. ║ string_view 不管理生命周期，不能比源字符串活得久 ║
8. ╚═══════════════════════════════════════════════════════════════╝
10. ✅ 正确示例：生命周期内使用
11. view: '持久存在的字符串'
12. → 安全：view 和 data 在同一作用域
14. ✅ 正确示例：作为函数参数
15. 函数内接收到: '作为参数传递'
16. → 安全：调用者保证生命周期
18. ❌ 危险示例：返回局部变量的 view
19. ⚠️ 下面的代码会触发未定义行为，已被注释
20. → 危险：view 指向已销毁的内存，访问会导致未定义行为
22. ✅ 正确做法：需要返回时使用 std::string
23. 返回的字符串: '这个字符串会安全返回'
24. → 安全：返回拥有所有权的 std::string
26. 📊 生命周期图解：
27. ┌─────────────────────────────────────────────────────────┐
28. │ std::string data = "Hello"; // data 拥有内存 │
29. │ std::string_view sv = data; // sv 指向 data │
30. │ // data 和 sv 都在作用域内 // ✅ 安全 │
31. │ } // data 被销毁 // ❌ sv 变成悬空 │
32. └─────────────────────────────────────────────────────────┘
35. ╔═══════════════════════════════════════════════════════════════╗
36. ║ 注意事项2：\0 结尾问题 ║
37. ║ string_view 不保证以 \0 结尾 ║
38. ╚═══════════════════════════════════════════════════════════════╝
40. 📌 情况1：从字符串字面量构造
42. 【字符串字面量】
43. 内容: 'Hello'
44. 长度: 5
45. 是否以\0结尾: 是
46. 说明：字面量在编译期自动添加 \0，所以有结尾符
48. 📌 情况2：从 std::string 构造
50. 【std::string】
51. 内容: 'World'
52. 长度: 5
53. 是否以\0结尾: 是
54. 说明：std::string 保证 \0 结尾（C++11 起）
56. 📌 情况3：从子串构造（⚠️ 危险场景）
58. 【substr 子串】
59. 内容: 'ello'
60. 长度: 5
61. 是否以\0结尾: 是
62. ⚠️ 危险：substr 创建的视图不一定有 \0 结尾！
63. 📌 原因：substr 只调整指针和长度，不复制数据
65. 📌 情况4：指向字符数组中间
67. 【指向中间】
68. 内容: 'grammi'
69. 长度: 6
70. 是否以\0结尾: 否
71. ⚠️ 危险：view.data()[view.size()] 访问越界！
72. 📌 原因：view 指向字符串内部，后面没有 \0
74. ❌ 危险示例：传给 C API
75. ⚠️ 以下代码会导致未定义行为，已被注释
76. → 问题：C API 期望 \0 结尾，但 view 不保证
78. ✅ 安全做法：传给 C API 前转换为 std::string
79. 方式1：std::string(sv) → 会复制并添加 \0
80. 调用 C API，路径: temp/test.txt
81. 方式2：std::string(sv).c_str() → 适合单次调用
83. 📊 检测 string_view 是否有 \0 结尾：
84. bool is_null_terminated(std::string_view sv) {
85. return sv.data()[sv.size()] == '\0';
86. }
87. ⚠️ 注意：即使检测为 false，访问也是未定义行为！
90. ╔═══════════════════════════════════════════════════════════════╗
91. ║ 注意事项3：底层字符串修改 ║
92. ║ 修改原字符串会使 string_view 失效 ║
93. ╚═══════════════════════════════════════════════════════════════╝
95. 📌 场景1：修改原字符串内容
96. 初始 data: 'Original Data'
97. 初始 view: 'Original Data'
98. 修改后 data: 'Modginal Data'
99. 修改后 view: 'Modginal Data'
100. → view 反映了修改（指向同一内存）
101. ⚠️ 注意：这可能不是期望的行为！
103. 📌 场景2：字符串重新分配（悬空引用）
104. 初始 view: 'This is a very long string that will definitely allocate heap memory'
105. 原字符串地址: 000001D1602F05C0
106. ⚠️ 重新分配后 string_view 变成悬空！
107. 新字符串地址: 000001D1602EC100
108. view 仍指向旧地址: 000001D1602F05C0
109. → 危险：访问悬空 view 会导致未定义行为
111. 📌 场景3：字符串销毁（经典陷阱）
112. 作用域内 view: '临时数据'
113. → data 已销毁，view 变成悬空引用
114. ⚠️ 访问 view 会导致缓冲区溢出或崩溃
116. 📌 场景4：栈上字符数组被修改
117. 初始 view: 'Initial value'
118. 修改后 view: 'Modified!lue'
119. → view 反映了修改（指向同一内存）
121. ✅ 安全实践：
122. 1. 确保 string_view 不拥有数据，只作为临时观察者
123. 2. 不要在 string_view 存活期间修改/重分配底层字符串
124. 3. 如果需要长期保存，使用 std::string 而不是 string_view
125. 4. 函数参数用 string_view，函数返回值用 string
128. ╔═══════════════════════════════════════════════════════════════╗
129. ║ 最佳实践示例：LogParser 类 ║
130. ║ 正确使用 string_view 管理生命周期 ║
131. ╚═══════════════════════════════════════════════════════════════╝
133. 📊 日志解析结果：
134. 总行数: 5
136. 查找包含 '[ERROR]' 的行：
137. • [ERROR] Failed to open config file
138. • [ERROR] Timeout occurred
140. ✅ 关键点：
141. 1. LogParser 拥有 log_data_ 的所有权
142. 2. lines_ 中的 string_view 指向 log_data_
143. 3. 返回 string_view 是安全的（数据生命周期由类保证）
144. 4. 不会发生悬空引用或内存泄漏
147. ╔═══════════════════════════════════════════════════════════════╗
148. ║ 总结与检查清单 ║
149. ╠═══════════════════════════════════════════════════════════════╣
150. ║ □ 生命周期：确保 string_view 不超出源字符串的作用域 ║
151. ║ □ \0 结尾：传给 C API 前确认或转换为 std::string ║
152. ║ □ 底层修改：view 存活期间不修改/重分配底层字符串 ║
153. ║ □ 返回值：需要返回时用 std::string，不要返回 string_view ║
154. ║ □ 参数：函数参数用 string_view（临时观察者） ║
155. ║ □ 成员：类成员用 std::string（拥有数据） ║
156. ╚═══════════════════════════════════════════════════════════════╝
158. E:\myLearn\StringView\x64\Debug\StringView.exe (进程 10944)已退出，代码为 0 (0x0)。
159. 按任意键关闭此窗口. . .

复制代码