现代 C++ 实用数据结构与工具 on Dorkytiger 的小屋

`std::variant` —— 类型安全联合体

Mon, 01 Jan 0001 00:00:00 +0000

解决什么问题？

// ❌ 传统 union 的问题
union Value {
    int i;
    double d;
    const char* s;
};

Value v;
v.i = 42;        // 现在 v 存的是 int
v.d = 3.14;      // 现在 v 存的是 double，覆盖了 int
// 编译器不管！v.i 现在是垃圾数据，但代码能访问 v.i → 未定义行为！
// 你必须自己用 tag 记录当前类型，但很容易忘记

variant 的承诺：编译期记住当前是哪种类型，访问错了会报错/抛异常。

什么时候用？

场景	为什么选 variant
函数返回"要么是正常结果，要么是错误信息"	替代 `pair<bool, T>` 或 -1 这样的哨兵值
解析器（JSON、INI、YAML）的节点类型	JSON 值可以是 string/number/array/object
状态机	状态是多种不同的结构体，但同一时刻只有一种
返回异构类型	函数可能返回 int、double 或 string

三种访问方式（选哪种？）

std::variant<int, double, std::string> v = 42;

// 方式 1：get<T>——你知道当前是什么类型时用
int val = std::get<int>(v);     // ✅ 正确
double val2 = std::get<double>(v); // ❌ 抛 bad_variant_access

// 方式 2：get_if<T>——不确定时用，安全
if (auto* p = std::get_if<double>(&v)) {
    // p 是 double*，当前 v 存的是 double 时才进入
} else if (auto* p = std::get_if<int>(&v)) {
    // 当前 v 存的是 int
}

// 方式 3：visit——最推荐，"我不管是什么类型，你帮我处理每个类型"
std::visit([](const auto& val) {
    // 编译器会为 int/double/string 各生成一个 lambda 实例
    // val 在三个实例中分别是 int、double、string
    std::cout << val;
}, v);

我推荐 visit：因为你不写大量 if-else，不容易漏掉某个类型。而且 visit 是编译期展开的，没有运行时成本。

`std::optional` —— 可能有值，也可能没有

Mon, 01 Jan 0001 00:00:00 +0000

解决什么问题？

// ❌ 传统方式：约定特殊值代表"没有找到"
size_t find(const std::vector<int>& v, int x) {
    for (size_t i = 0; i < v.size(); i++)
        if (v[i] == x) return i;
    return -1;  // ❌ -1 对 size_t 来说是 18446744073709551615！而且如果索引 0 是有效值呢？
}

// ❌ 另一种传统方式：输出参数
bool find(const std::vector<int>& v, int x, size_t& out_index);
// API 调用者必须声明一个变量传进去，很啰嗦

optional 的承诺：用类型系统表达"返回值可能不存在"。

什么时候用？

场景	不用 optional	用 optional
容器查找	返回 -1 或 `end()`	返回 `optional<iterator>`
解析	返回 `bool` + 输出参数	返回 `optional<T>`
从可能为空的配置取值	抛异常	返回 `optional<T>`
数据库查询	返回 nullptr	返回 `optional<Record>`

std::optional<size_t> find(const std::vector<int>& v, int x) {
    for (size_t i = 0; i < v.size(); i++)
        if (v[i] == x) return i;     // ✅ 没有歧义
    return std::nullopt;              // ✅ 明确表达"没有"
}

auto result = find(vec, 42);
if (result.has_value()) {
    // 进入这里说明 result 一定有效
    size_t index = result.value();  // 或者 *result
} else {
    std::cout << "not found";
}

性能：optional<T> 不分配堆内存，和 T 占同样大的空间（+一个 bool 标记位，通常利用 padding 字节，不增加 sizeof）。

`std::any` —— 能存任意类型的容器

Mon, 01 Jan 0001 00:00:00 +0000

和 `void*` 有什么区别？

// void*：完全不安全
void* storage = new int(42);
// 一年后别的开发者：
int* p = static_cast<int*>(storage); // 假设有人告诉他是 int
// 但如果存储的是 double 呢？💥

// std::any：安全
std::any storage = 42;
storage = 3.14;
storage = std::string("hello");

// 取出时必须指定类型，错了就抛异常
try {
    int val = std::any_cast<int>(storage); // ❌ 当前是 string
} catch (const std::bad_any_cast&) {
    std::cout << "wrong type";
}

什么时候真的需要 `any`？

很少。variant 比 any 更好（variant 在编译期知道可能的类型集，any 不知道）。

少数的场景：插件系统/动态配置系统，你需要存储"类型完全未知、运行时才能确定"的数据：

// 配置系统：每个配置项的类型只能在加载时确定
std::unordered_map<std::string, std::any> runtime_config;

runtime_config["timeout"] = 30;      // int
runtime_config["rate"] = 3.14;       // double
runtime_config["name"] = "server"s;  // string

// 运行时才知道类型
std::string key = get_user_input();  // 用户输入 "rate"
if (runtime_config[key].has_value()) {
    // 但这里不知道是 int 还是 double，只能 try 所有类型
}

能用 variant 的场景就别用 any，因为 any 底层用虚表做类型擦除，每次 any_cast 都有一次 RTTI 比较。

`std::string_view` —— 字符串的"借用"视图

Mon, 01 Jan 0001 00:00:00 +0000

解决什么问题？

// ❌ 问题：把字符串切一段出来，就要分配内存
std::string full = "user:warren:logged_in";
std::string name = full.substr(5, 6);  // "warren" → 分配堆内存！

// ✅ string_view：只记录指针和长度，不拷贝
std::string_view full_sv = full;
std::string_view name_sv = full_sv.substr(5, 6);  // "warren" → 不分配！
// name_sv.ptr 指向 full 内部第 6 个字符的位置

什么时候用？

场景	用 string_view
函数参数，只读字符串	`void parse(std::string_view input)`——接受 `string`、`char*`、`string_view` 而不拷贝
子串提取，不需要修改	`sv.substr(pos, len)` 不分配内存
快速比较前缀/后缀	`sv.starts_with("http")` `sv.ends_with(".png")`
日志/消息解析	从大字符串中切出各字段而不拷贝

致命陷阱：生命周期

std::string_view get_name() {
    std::string temp = "temporary";
    return temp;  // ✅ 赋值时 temp 还活着
}  // ❌ temp 析构，sv 悬垂！

auto sv = get_name();
std::cout << sv;  // 💥 Use-After-Free！可能打印出乱码或 crash

规则：string_view 不拥有数据。你必须保证原始字符串活到 string_view 用完。

`std::span` —— 连续内存的"借用"视图

Mon, 01 Jan 0001 00:00:00 +0000

string_view 是"字符的 view"；span 是"任意类型的 view"。

解决什么问题？

// ❌ 传统函数签名：零散的指针+长度
void process(const float* data, size_t count);
// 调用者容易传错：process(arr, 1000) // 如果 arr 只有 500 个元素呢？

// ✅ span：长度自带
void process(std::span<const float> data);
// 调用者：process(arr); // 自动推导长度
// 或者：process(vec);   // vector 也能直接传

span 的内存结构：

span<float> s(vec);
栈上占用 16 字节（64 位）:
+──────────────────+──────────────────+
| ptr (8字节)       | size (8字节)      |
| 指向 vec.data()   | vec.size()        |
+──────────────────+──────────────────+

没有任何堆分配，不拥有数据，只是一个指针 + 长度。

什么时候用？

// 1. 替代 (T* data, size_t len) —— 最常见的场景
void process(std::span<const int> data);

// 2. 需要同时支持 vector / array / C 数组的函数
void sort_all(std::span<int> data) {
    std::sort(data.begin(), data.end());
}

std::vector<int> v = {3, 1, 4, 1, 5};
int arr[] = {2, 7, 1, 8};
sort_all(v);    // ✅ vector
sort_all(arr);  // ✅ C 数组（自动推导长度为 4）

// 3. 子范围操作
auto first_half = s.first(s.size() / 2);  // 取前半，不拷贝
auto second_half = s.last(s.size() / 2);   // 取后半
auto middle = s.subspan(2, 5);             // 取 [2, 7)

和 `string_view` 完全一样的生命周期规则

delete 原始数组后，span 悬垂。

`std::format` —— C++20 的字符串格式化

Mon, 01 Jan 0001 00:00:00 +0000

为什么需要它？

// printf：类型不安全，不检查 %d 和参数是否匹配
printf("int: %d, str: %s\n", 42); // ❌ 少传一个参数 → 未定义行为！

// ostringstream：性能差，写起来啰嗦
std::ostringstream oss;
oss << "int: " << 42 << ", str: " << "hello";
std::string s = oss.str(); // 多个 << 拼接，每个 << 有一次虚函数调用

// format：编译期检查，性能最高
std::string s = std::format("int: {}, str: {}", 42, "hello");
// 如果花括号个数和参数个数不匹配 → 编译错误！

性能对比

// 格式化 100 万次
std::format("value = {}", x);                   // ~30ms
snprintf(buf, 64, "value = %d", x);             // ~50ms
ss << "value = " << x; ss.str();                // ~150ms

为什么 format 最快？

printf 运行时解析格式字符串（检查 %d、%f 等）。
ostringstream 每次 << 调用虚函数，多次分配内存。
format 在编译期解析 {}，运行时只做简单的替换和参数格式化。

常用格式控制

std::format("{:.2f}", 3.14159);       // "3.14"（保留两位小数）
std::format("{:>10}", "hello");       // "     hello"（右对齐，宽度 10）
std::format("{:<10}", "hello");       // "hello     "（左对齐）
std::format("{:^10}", "hello");       // "  hello   "（居中）
std::format("{:0>6}", 42);            // "000042"（零填充）
std::format("{:x}", 255);             // "ff"（十六进制小写）
std::format("{:X}", 255);             // "FF"（十六进制大写）
std::format("{:b}", 255);             // "11111111"（二进制）

第九阶段总结——一张表选哪个

Mon, 01 Jan 0001 00:00:00 +0000

你需要	用这个	别用这个
一种类型，可能不存在	`optional<T>`	`pair<bool, T>` 或特殊值 -1
多种类型，但只有编译期已知的几种	`variant<A, B, C>`	`union` 或 `void*`
每一种可能的类型（运行时才确定）	`any`	`void*`
只读字符串参数	`string_view`	`const string&`（可能触发分配）
连续内存只读参数	`span<const T>`	`(T*, size_t)`
类型安全格式化	`format`	`printf` 或 `ostringstream`

现代 C++ 实用数据结构与工具 on Dorkytiger 的小屋

`std::variant` —— 类型安全联合体

解决什么问题？

什么时候用？

三种访问方式（选哪种？）

`std::optional` —— 可能有值，也可能没有

解决什么问题？

什么时候用？

`std::any` —— 能存任意类型的容器

和 void* 有什么区别？

什么时候真的需要 any？

`std::string_view` —— 字符串的"借用"视图

解决什么问题？

致命陷阱：生命周期

`std::span` —— 连续内存的"借用"视图

解决什么问题？

什么时候用？

和 string_view 完全一样的生命周期规则

`std::format` —— C++20 的字符串格式化

为什么需要它？

性能对比

常用格式控制

第九阶段总结——一张表选哪个

和 `void*` 有什么区别？

什么时候真的需要 `any`？

和 `string_view` 完全一样的生命周期规则