C++ `std::string_view`：C++17 字符串视图的零拷贝妙用

好的，各位观众老爷，欢迎来到今天的“C++冷兵器复兴计划”特别节目。今天我们要聊的，是C++17引入的一个神器：std::string_view。这玩意儿，说白了，就是字符串的“阅后即焚”版，看一眼就走，绝不拷贝，用得好，能让你的代码跑得飞起！

开场白：字符串的世界，拷贝的烦恼

话说在C++的世界里，字符串处理一直是个让人头疼的问题。以前我们常用的std::string，那可是个拷贝狂魔。每次你把一个字符串传给函数，它都要创建一个新的副本。这玩意儿多了，内存哗哗地烧，性能蹭蹭地掉。

想象一下，你有一个巨大的文本文件，里面存了几百万行数据。如果你要写一个函数来分析每一行，每次都用std::string拷贝，那得拷贝到猴年马月去？你的CPU估计都要罢工抗议了！

std::string_view：救星来了！

这时候，std::string_view就像一位穿着披风的超级英雄，从天而降，拯救了我们于水火之中。它最大的特点就是：零拷贝！

它就像一个轻量级的引用，指向一个现有的字符串（可以是std::string，也可以是C风格的字符串），但它本身并不拥有这个字符串。也就是说，它只是“看”着这个字符串，而不是“拥有”它。

这样一来，当你把一个std::string_view传给函数时，它不会创建新的副本，而是直接传递这个引用。速度快得就像闪电侠，内存开销也小得可以忽略不计。

std::string_view的庐山真面目

我们先来看看std::string_view长啥样：

#include <iostream>
#include <string_view>

int main() {
  std::string str = "Hello, world!";
  std::string_view view = str;

  std::cout << "String: " << str << std::endl;
  std::cout << "View: " << view << std::endl;

  return 0;
}

这段代码很简单，我们创建了一个std::string对象str，然后用它来初始化一个std::string_view对象view。view现在就指向了str的内存区域。

std::string_view的特点：

只读： std::string_view是只读的，你不能通过它来修改底层的字符串。如果你试图修改，编译器会毫不留情地给你报错。这也有好处，防止了意外修改原始字符串。
轻量级： std::string_view通常只包含两个成员：一个指向字符串首字符的指针，和一个表示字符串长度的整数。因此，它非常轻量级，拷贝的代价非常小。
不拥有所有权： 这是最关键的一点！std::string_view不拥有它指向的字符串的所有权。这意味着，如果原始字符串被销毁了，std::string_view就会变成一个“悬挂指针”，指向无效的内存区域。使用时要格外小心！

std::string_view的常用方法：

std::string_view提供了一系列方法，方便我们对字符串进行操作。下面列出一些常用的方法：

方法	描述
`length()`	返回字符串的长度。
`size()`	返回字符串的长度（和`length()`一样）。
`empty()`	如果字符串为空，返回`true`，否则返回`false`。
`data()`	返回指向字符串首字符的指针（`const char*`）。
`begin()`	返回指向字符串首字符的迭代器。
`end()`	返回指向字符串末尾的迭代器。
`substr(pos, n)`	返回一个新的`std::string_view`，表示原始字符串从位置`pos`开始的`n`个字符的子串。
`remove_prefix(n)`	从字符串的开头移除`n`个字符。
`remove_suffix(n)`	从字符串的末尾移除`n`个字符。
`find(str)`	在字符串中查找子串`str`，返回子串的起始位置。如果找不到，返回`std::string_view::npos`。
`rfind(str)`	在字符串中反向查找子串`str`，返回子串的起始位置。如果找不到，返回`std::string_view::npos`。
`starts_with(str)`	检查字符串是否以子串`str`开头。
`ends_with(str)`	检查字符串是否以子串`str`结尾。

代码示例：std::string_view的妙用

光说不练假把式，我们来写几个例子，看看std::string_view在实际应用中有多么强大。

例子1：分割字符串

假设我们有一个字符串，包含用逗号分隔的多个字段。我们要把这些字段提取出来。

#include <iostream>
#include <string_view>
#include <vector>

std::vector<std::string_view> split(std::string_view str, char delimiter) {
  std::vector<std::string_view> result;
  size_t start = 0;
  size_t end = str.find(delimiter);

  while (end != std::string_view::npos) {
    result.push_back(str.substr(start, end - start));
    start = end + 1;
    end = str.find(delimiter, start);
  }

  result.push_back(str.substr(start));
  return result;
}

int main() {
  std::string data = "apple,banana,orange,grape";
  std::vector<std::string_view> fields = split(data, ',');

  for (const auto& field : fields) {
    std::cout << field << std::endl;
  }

  return 0;
}

在这个例子中，split函数接收一个std::string_view作为参数，并返回一个std::string_view的vector。注意，我们没有进行任何字符串拷贝！所有的操作都是在std::string_view上进行的，效率非常高。

例子2：解析URL

假设我们要解析一个URL，提取出协议、主机名和路径。

#include <iostream>
#include <string_view>

struct URL {
  std::string_view protocol;
  std::string_view hostname;
  std::string_view path;
};

URL parse_url(std::string_view url) {
  URL result;

  size_t protocol_end = url.find("://");
  if (protocol_end == std::string_view::npos) {
    return result; // Invalid URL
  }
  result.protocol = url.substr(0, protocol_end);
  url.remove_prefix(protocol_end + 3);

  size_t hostname_end = url.find('/');
  if (hostname_end == std::string_view::npos) {
    result.hostname = url;
    result.path = "";
  } else {
    result.hostname = url.substr(0, hostname_end);
    result.path = url.substr(hostname_end);
  }

  return result;
}

int main() {
  std::string url = "https://www.example.com/path/to/resource";
  URL parsed_url = parse_url(url);

  std::cout << "Protocol: " << parsed_url.protocol << std::endl;
  std::cout << "Hostname: " << parsed_url.hostname << std::endl;
  std::cout << "Path: " << parsed_url.path << std::endl;

  return 0;
}

在这个例子中，parse_url函数同样接收一个std::string_view作为参数，并返回一个包含std::string_view成员的结构体。我们通过substr和remove_prefix等方法，在std::string_view上进行各种操作，而无需进行任何字符串拷贝。

std::string_view的注意事项：避免悬挂指针！

虽然std::string_view很强大，但使用时一定要小心，避免出现悬挂指针。因为std::string_view不拥有它指向的字符串的所有权，所以当原始字符串被销毁后，std::string_view就会变成一个无效的指针。

例如：

#include <iostream>
#include <string_view>

std::string_view get_substring(const std::string& str, size_t pos, size_t len) {
  return std::string_view(str).substr(pos, len); // DANGER!
}

int main() {
  std::string str = "Hello, world!";
  std::string_view view = get_substring(str, 0, 5); // view holds "Hello"
  std::cout << view << std::endl; // Output: Hello

  // str goes out of scope here! The underlying data is gone.

  // Using view here would be undefined behavior!
  // std::cout << view << std::endl; // Potential crash!

  return 0;
}

在这个例子中，get_substring函数返回一个std::string_view，指向str的一个子串。但是，当str在main函数中超出作用域后，view就变成了一个悬挂指针。如果继续使用view，程序可能会崩溃。

如何避免悬挂指针？

确保原始字符串的生命周期比std::string_view长。 这是最简单也是最有效的方法。
如果需要长期存储字符串，请使用std::string进行拷贝。 虽然拷贝会带来一定的性能损失，但可以保证数据的安全性。
使用智能指针管理字符串的生命周期。 例如，可以使用std::shared_ptr来共享字符串的所有权。

std::string_view vs. const std::string&：选哪个？

你可能会问，既然std::string_view这么好用，那是不是可以完全取代const std::string&了？答案是：视情况而定！

const std::string& 也是一种引用传递，避免了拷贝。但它有一个缺点：它只能接受std::string类型的参数。如果你想传递一个C风格的字符串，你需要先把它转换成std::string，这会带来额外的开销。

std::string_view则更加灵活，它可以接受std::string、C风格的字符串，甚至是字符数组。而且，它还可以隐式地从这些类型转换而来。

特性	`const std::string&`	`std::string_view`
接受的类型	`std::string`	`std::string`、C风格字符串、字符数组
拷贝	无	无
所有权	无	无
隐式转换	无	有
使用场景	只需要处理`std::string`	需要处理多种字符串类型，且不需要修改字符串

总结：std::string_view，C++字符串处理的瑞士军刀

std::string_view是C++17引入的一个非常有用的工具，它可以帮助我们避免字符串拷贝，提高程序的性能。但是，使用时一定要小心，避免出现悬挂指针。

总的来说，std::string_view就像一把瑞士军刀，功能强大，用途广泛。只要你掌握了它的使用方法，就能在字符串处理的世界里游刃有余。

最后的忠告：

在不需要修改字符串的情况下，尽量使用std::string_view。
注意std::string_view的生命周期，避免悬挂指针。
根据实际情况，选择std::string_view或const std::string&。

希望今天的讲解对你有所帮助。记住，学习C++就像练武功，要多练多用，才能真正掌握。下次再见！

发表回复 取消回复

发表回复取消回复