现代 C++ 高效特性
用好 optional/variant/string_view 与 C++20 ranges 减少样板代码
#这一章解决什么问题
C++11 之后标准库补上了一批「让意图显式化」的工具:值可能不存在就用 optional,值可能是几种类型之一就用 variant,只想读一段字符串就用 string_view。这些类型的共同特点是几乎零运行时开销,却把过去靠注释和约定表达的信息变成了编译器可检查的类型。
如果你熟悉 Java,可以把 std::optional<T> 理解成 Optional<T>——但它不是对象包装器,optional<int> 里躺着一个真正的 int,没有额外堆分配。如果你熟悉 Python,tuple 解包、dict.get() 返回 None 的习惯在这里对应结构化绑定和 optional。JS 开发者则会觉得 std::variant 有点像联合类型(TypeScript 的 string | number),但它是类型安全的带标签联合,访问错类型会抛异常而不是静默出错。本章默认 C++17,C++20 特性会明确标注。
#结构化绑定
C++17 引入,一句话拆开 struct、pair、tuple 和数组。Python 的 name, age = row、JS 的 const {name, age} = obj 在这里的对应物是 auto [name, age] = row;。区别在于:C++ 版本创建的是绑定名字,不是新变量,可以通过 auto& 或 auto&& 绑定到原对象的成员上,实现原地修改。
#include <iostream>
#include <map>
#include <string>
#include <tuple>
struct Point { double x; double y; };
std::tuple<int, std::string, bool> query() { return {42, "answer", true}; }
int main() {
// 1) 拆 struct 成员(按声明顺序,不是按名字)
Point p{3.5, 7.0};
auto [x, y] = p;
std::cout << x << "," << y << "\n";
// 2) auto& 绑定引用,可原地修改
auto& [rx, ry] = p;
rx = 10.0;
std::cout << "p.x = " << p.x << "\n";
// 3) 遍历 map 时最常见也最舒服
std::map<std::string, int> scores{{"alice", 90}, {"bob", 85}};
for (const auto& [name, score] : scores) {
std::cout << name << ": " << score << "\n";
}
// 4) if 初始化语句 + 结构化绑定(C++17),把作用域收窄
if (auto [code, msg, ok] = query(); ok) {
std::cout << code << " " << msg << "\n";
}
}std::tuple 的绑定顺序是模板参数顺序,std::pair 是 first/second,聚合类是成员声明顺序。三个实用提醒:一是绑定名字不能被 lambda 捕获(C++20 之前),写回调时得先拷贝到普通变量;二是 auto [a, b] 对整个结构体做了一份拷贝,大对象请用 auto&;三是结构化绑定无法用于 static 或 thread_local 声明,也不能直接用于位域成员。
另外,如果需要只取其中一部分,可以用 std::ignore 占位(C++17 起结构化绑定本身也允许不解包全部成员,但 std::tie 的用法仍常见于老代码):std::tie(ok, std::ignore) = result; 这类写法在解析多返回值时很方便。
#std::optional:显式表达「可能没有」
替代过去的三种坏味道:用哨兵值(-1、nullptr)、用输出参数 bool tryGet(T& out)、或者直接抛异常。optional 让「无值」成为类型的一部分。
#include <iostream>
#include <optional>
#include <string>
#include <vector>
// 返回 optional,调用方无法忽略「没找到」这一事实
std::optional<int> find_first_even(const std::vector<int>& v) {
for (int x : v) {
if (x % 2 == 0) return x; // 隐式构造 optional
}
return std::nullopt;
}
int main() {
std::vector<int> data{1, 3, 4, 7};
// 1) has_value + value
if (auto r = find_first_even(data); r.has_value()) {
std::cout << "found " << *r << "\n";
}
// 2) value_or:给默认值,Python 的 d.get(k, default)
std::cout << find_first_even(data).value_or(-1) << "\n";
// 3) C++23 才有 and_then/or_else/transform;C++17 只能手写
std::optional<int> empty = std::nullopt;
std::cout << empty.value_or(999) << "\n";
// 4) 避免在热路径上这样写:value() 在无值时抛 bad_optional_access
try {
std::cout << empty.value() << "\n";
} catch (const std::bad_optional_access& e) {
std::cout << "no value: " << e.what() << "\n";
}
}对比 Java 的 Optional:Java 官方建议不要把它用作字段类型,C++ 没有这个限制,optional 作成员很常见(表示「尚未初始化的配置项」)。另一个关键差异是 Java 的 Optional 是引用类型、本身可能为 null,反而引入了新的 NPE 风险;C++ 的 optional<T> 是值语义,变量本身永远有效,sizeof(optional<int>) 通常只比 int 大 4 字节(一个标志位),没有额外堆分配。
什么时候不该用 optional?当「无值」本身就是一种需要区分的详细错误时,用 variant<T, Error> 或者异常更合适;当「无值」是逻辑上不可能的情况时,直接返回 T 并让调用方信任契约,过度使用 optional 会让代码到处都是 value_or 和解引用,可读性反而下降。
#std::variant 与 std::any
variant 是类型安全的联合体:它知道当前存的是哪种类型,用 std::visit 分派。any 则是完全的类型擦除,能装任何东西,取回时必须知道确切类型。优先用 variant——它在编译期就限定了可能类型,any 基本是「放弃类型检查」的信号。
#include <iostream>
#include <string>
#include <type_traits>
#include <utility>
#include <variant>
#include <vector>
using Value = std::variant<int, double, std::string>;
// 访问者可以是泛型 lambda,编译器为每种类型生成一个分支
void print(const Value& v) {
std::visit([](const auto& x) {
using T = std::decay_t<decltype(x)>;
if constexpr (std::is_same_v<T, std::string>) {
std::cout << "\"" << x << "\"";
} else {
std::cout << x;
}
}, v);
}
int main() {
std::vector<Value> row{1, 3.14, std::string("hello")};
for (const auto& v : row) {
std::cout << "index = " << v.index() << " value = ";
print(v);
std::cout << "\n";
}
// 单类型访问:类型不符抛 bad_variant_access
try {
std::cout << std::get<int>(row[0]) << "\n";
std::cout << std::get<int>(row[1]) << "\n"; // 抛异常
} catch (const std::bad_variant_access&) {
std::cout << "wrong type\n";
}
// get_if 返回指针,不抛异常,是更常用的写法
if (auto p = std::get_if<double>(&row[1])) {
std::cout << "double: " << *p << "\n";
}
}std::visit 在这里配合泛型 lambda 和 if constexpr(本章后面会讲),是 C++17 里最接近「模式匹配」的东西。TypeScript 的联合类型收窄、Rust 的 match 都在这个方向,C++ 的写法略啰嗦但完全零开销——visit 通常编译成跳转表,没有虚函数调用。而且它是穷尽性检查的:漏掉一种类型就是编译错误,这比 if/else 链或者 switch 加枚举安全得多。
std::any 则是完全的类型擦除,能装任何类型,取回时必须用 std::any_cast<T> 且必须知道确切类型,写错就抛 bad_any_cast。它基本等于「放弃编译期类型检查」,只在插件系统、脚本绑定这类真正动态的边界上才合理。判断标准很简单:如果可能的类型是有限的几种枚举得出来的,就用 variant;如果类型集合开放且不可枚举,才考虑 any。
#string_view 与 span:非拥有的视图
std::string_view(C++17)是 {指针, 长度} 的轻量视图,不拥有数据。把函数参数从 const std::string& 改成 std::string_view 有两个直接收益:传字符串字面量不再构造临时 string;传子串不再分配内存。
#include <cctype>
#include <iostream>
#include <string>
#include <string_view>
// 旧写法:const std::string& 传字面量会触发一次堆分配
// 新写法:string_view 接受 string / char* / 字面量,全部零分配
size_t count_words(std::string_view text) {
size_t n = 0;
bool in_word = false;
for (char c : text) {
if (std::isspace(static_cast<unsigned char>(c))) {
in_word = false;
} else if (!in_word) {
in_word = true;
++n;
}
}
return n;
}
int main() {
std::string s = "hello modern cpp";
std::cout << count_words(s) << "\n"; // 无拷贝
std::cout << count_words("literal, no allocation") << "\n"; // 无分配
std::cout << count_words(s.substr(0, 5)) << "\n"; // substr 会产生临时
// 陷阱:视图不拥有数据,源销毁即悬垂
std::string_view dangling;
{
std::string tmp = "temp";
dangling = tmp; // tmp 析构后 dangling 失效
}
// std::cout << dangling; // 未定义行为
}唯一的铁律:string_view 的生命周期不能超过它指向的数据。 函数参数用它最安全;作为返回值或成员变量时必须极其谨慎。同理,std::span<T>(C++20)是连续内存的非拥有视图,统一了 vector、array、C 数组的接口:
// C++20
#include <span>
#include <iostream>
#include <vector>
void scale(std::span<double> data, double factor) {
for (double& x : data) x *= factor;
}
int main() {
std::vector<double> v{1.0, 2.0, 3.0};
scale(v, 10.0); // 整个容器
scale(std::span{v}.subspan(0, 2), 0.5); // 前两个元素
scale(v, 1.0);
double arr[] = {1, 2, 3};
scale(arr, 2.0); // C 数组也行
for (double x : v) std::cout << x << " ";
}过去的替代方案是 void scale(double* p, size_t n),既丢长度信息又容易越界;span 保留了 .size() 并支持范围 for。
#C++20 范围库与视图管道
Ranges 把「算法 + 迭代器」升级为可直接组合的管道,| 操作符串联,且视图是惰性求值的——不会生成中间容器。熟悉 Python 的 filter/map 生成器或 JS 的数组链式调用的话,这里会非常自然;区别是 C++ 版本全程零分配。
// C++20
#include <iostream>
#include <ranges>
#include <string>
#include <vector>
int main() {
std::vector<int> nums{1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
// 管道:过滤偶数 -> 平方 -> 取前 3 个
auto result = nums
| std::views::filter([](int n) { return n % 2 == 0; })
| std::views::transform([](int n) { return n * n; })
| std::views::take(3);
for (int x : result) std::cout << x << " "; // 4 16 36
std::cout << "\n";
// 直接对整个容器调用算法,不必写 begin/end
if (std::ranges::any_of(nums, [](int n) { return n > 9; })) {
std::cout << "has big number\n";
}
// C++23 的 views::zip / C++20 可用 iota 生成序列
for (int x : std::views::iota(1, 6)) std::cout << x << " ";
std::cout << "\n";
}注意:视图管道里的 lambda 捕获引用时要小心生命周期;另外 filter 要求谓词是纯函数,否则结果不可预测。
#折叠表达式与 if constexpr
可变参数模板在 C++11 需要递归展开,C++17 的折叠表达式把这件事压缩成一行。
#include <iostream>
#include <string>
// 一元右折叠:把参数包用 + 串起来
template <typename... Args>
auto sum(Args... args) {
return (args + ...);
}
// 二元左折叠:带初始值,且能处理空包
template <typename... Args>
auto sum2(Args... args) {
return (0 + ... + args);
}
// 逗号折叠:对包中每个元素执行副作用
template <typename... Args>
void print_all(Args&&... args) {
(std::cout << ... << std::forward<Args>(args)) << "\n";
}
// 逻辑折叠:all_of 风格
template <typename... Args>
bool all_true(Args... args) {
return (... && args);
}
int main() {
std::cout << sum(1, 2, 3) << "\n"; // 6
std::cout << sum2(1, 2, 3) << "\n"; // 6
std::cout << sum2() << "\n"; // 0,空包也合法
print_all("a", 1, ' ', 2.5);
std::cout << std::boolalpha << all_true(true, 1, "x") << "\n";
}if constexpr(C++17)是编译期分支:不满足的分支根本不会被实例化,因此可以在分支里写对当前类型非法的代码。这是模板元编程从 SFINAE 泥潭里解脱出来的关键工具,也是上面 std::visit 能对不同成员类型写不同逻辑的原因。对比 Java/Python 的运行时 if,if constexpr 在编译后不留任何痕迹——另一分支连类型检查都不做。
#小结
- 结构化绑定(
auto [a, b] = ...)拆 tuple/pair/聚合类,配auto&可原地修改,配if初始化语句可收窄作用域。 std::optional<T>是值语义的「可能无值」,无堆分配;优先value_or和get_if风格,慎用会抛异常的value()。std::variant是类型安全联合体,配std::visit+ 泛型 lambda +if constexpr实现类模式匹配;std::any是最后手段。string_view/span是非拥有视图,零拷贝但不持有数据——生命周期是唯一的坑,函数参数最安全。- C++20 ranges 用
|惰性组合算法,无中间分配;C++17 折叠表达式和if constexpr大幅简化可变参数模板与编译期分支。
#练习
- 写一个
parse_int(std::string_view) -> std::optional<int>:解析失败返回nullopt。要求接受std::string、字面量和substr结果三种输入形式,且全程不发生堆分配。 - 用
std::variant<int, double, std::string>表示 JSON 的标量值,实现to_string(const Value&),用std::visit+if constexpr分别格式化三种类型。 - 把
std::span<int>版本的冒泡排序写出来,分别传入std::vector、std::array和 C 数组验证;再说明为什么不能用span存一个std::list的数据。 - (进阶,C++20)用 views 管道统计一个
vector<string>中长度大于 3 且以大写字母开头的字符串个数;然后改成普通循环版本,对比两者的汇编是否有额外分配。