C++中 optional variant any 的使用

在 C++17 中，std::optional、std::variant 和 std::any 是三个非常重要的 类型安全的"容器类"工具 ，它们都定义在 <optional>、<variant> 和 <any> 头文件中，用于处理可能缺失、多态类型或任意类型的值。它们增强了类型安全性，减少了对指针或 void* 的依赖。

一、std::optional<T> ------ 可选值（可能不存在的值）

📌 功能

表示一个值可能存在也可能不存在，替代使用特殊值（如 -1、nullptr）或输出参数来表示"无值"。

✅ 示例：查找成绩

#include <iostream>
#include <optional>
#include <map>

std::optional<int> find_grade(const std::map<std::string, int>& grades, const std::string& name) {
    auto it = grades.find(name);
    if (it != grades.end()) {
        return it->second;
    } else {
        return std::nullopt; // 显式表示"无值"
    }
}

int main() {
    std::map<std::string, int> grades = {{"Alice", 95}, {"Bob", 87}};

    auto grade = find_grade(grades, "Charlie");
    if (grade.has_value()) {
        std::cout << "Grade: " << *grade << std::endl;
    } else {
        std::cout << "No grade found." << std::endl;
    }

    // C++17 结构化绑定 + if 初始化（推荐写法）
    if (auto result = find_grade(grades, "Alice"); result) {
        std::cout << "Found: " << *result << std::endl;
    }

    return 0;
}

⚠️ 注意事项

• 使用前必须检查是否有值：has_value() 或 if(opt)。
• 解引用前确保有值，否则未定义行为（UB）。
• 不适合用于性能敏感的大对象（有额外开销）。
• std::nullopt 是空状态的标准表示。
• 不要用于代替布尔返回值（除非你确实需要携带一个可选的 T）。

二、std::variant<T1, T2, ...> ------ 类型安全的联合体（Union）

📌 功能

表示一个值可以是几种类型之一，是类型安全的 union 替代品。

✅ 示例：表达式求值支持 int 和 double

#include <iostream>
#include <variant>
#include <string>

using Value = std::variant<int, double, std::string>;

struct PrintVisitor {
    void operator()(int i) const { std::cout << "Int: " << i << std::endl; }
    void operator()(double d) const { std::cout << "Double: " << d << std::endl; }
    void operator()(const std::string& s) const { std::cout << "String: " << s << std::endl; }
};

int main() {
    Value v1 = 42;
    Value v2 = 3.14;
    Value v3 = std::string("Hello");

    std::visit(PrintVisitor{}, v1); // 输出: Int: 42
    std::visit(PrintVisitor{}, v2); // Double: 3.14
    std::visit(PrintVisitor{}, v3); // String: Hello

    // C++17 聚合初始化 + lambda 访问
    std::visit([](const auto& val) {
        std::cout << "Auto: " << val << std::endl;
    }, v1);

    return 0;
}

⚠️ 注意事项

• variant 总是包含其中一个类型，不能为"空"（除非包含 std::monostate 表示空状态）。
• 访问必须使用 std::get<T>(v) 或 std::visit。
• 使用 std::get<T>(v) 若类型不匹配会抛出 std::bad_variant_access 异常。
• 推荐使用 std::visit 配合函数对象或泛型 lambda 进行类型分发。
• 构造时自动选择最匹配的类型（注意隐式转换可能导致意外）。

示例：避免歧义构造

std::variant<int, bool> v = true;   // OK，但会变成 bool(true)
std::variant<int, bool> w = 1;      // 优先匹配 int(1)，不是 bool

三、std::any ------ 任意类型的值（类型擦除）

📌 功能

可以保存任何类型的值（类似 void* + 类型信息），但类型安全。

✅ 示例：配置项存储

#include <iostream>
#include <any>
#include <map>
#include <string>

int main() {
    std::map<std::string, std::any> config;
    config["name"] = std::string("Alice");
    config["age"] = 30;
    config["pi"] = 3.14159;
    config["active"] = true;

    // 安全访问
    if (auto it = config.find("age"); it != config.end()) {
        if (it->second.type() == typeid(int)) {
            std::cout << "Age: " << std::any_cast<int>(it->second) << std::endl;
        }
    }

    // any_cast 失败会抛出 std::bad_any_cast
    try {
        double d = std::any_cast<double>(config["age"]); // 错误类型
    } catch (const std::bad_any_cast& e) {
        std::cout << "Bad cast: " << e.what() << std::endl;
    }

    return 0;
}

⚠️ 注意事项

• 性能开销大（堆分配、类型信息存储）。
• 必须使用 std::any_cast<T> 正确提取，类型错误会抛异常。
• 支持拷贝，但被存的对象必须可拷贝。
• 不支持移动语义后原值仍可用（内部是共享所有权机制）。
• 尽量避免滥用，它削弱了编译时类型检查。

四、三者对比总结

特性	std::optional<T>	std::variant<T, U>	std::any
是否有值	可能无值（nullopt）	总有一个类型有效	总有一个类型（或空）
类型集合	固定：T 或 无	固定：T 或 U 或 ...	任意类型
类型安全	高	高	中（运行时检查）
性能	较好	好	差（堆分配、RTTI）
典型用途	返回可能失败的函数	多类型选择（如 JSON 值）	插件、配置、反射模拟
访问方式	*, ->, value()	std::get, std::visit	std::any_cast
异常风险	value() 无值时抛异常	std::get 类型错抛异常	any_cast 类型错抛异常

五、通用注意事项（C++17 使用建议）

1. 头文件

#include <optional>  // std::optional, std::nullopt
#include <variant>   // std::variant, std::visit, std::monostate
#include <any>       // std::any, std::any_cast

3. 避免过度使用

• std::any 应谨慎使用，尽量用多态或 variant 替代。
• variant 模板列表不宜过长（影响编译时间和可读性）。
• optional 比返回指针更安全，推荐用于工厂函数、查找函数。

4. 与 auto 和结构化绑定结合

if (auto result = compute(); result) {
    use(*result);
}

5. 异常安全

• 所有三者在构造、赋值时若类型抛异常，自身状态可能无效。
• any 和 variant 要求所含类型满足基本异常安全。

---

六、进阶技巧

使用 std::monostate 实现空 variant

std::variant<std::monostate, int, std::string> maybe_value;
maybe_value = std::monostate{}; // 表示"无值"

泛型 visitor（C++17 支持）

auto printer = [](const auto& x) { std::cout << x << std::endl; };
std::visit(printer, my_variant);

总结

工具	适用场景
std::optional<T>	"T 可能不存在" ------ 函数返回值、配置项可选
std::variant<T, U>	"值是 T 或 U 之一" ------ AST、状态机、JSON 类型
std::any	"值可以是任意类型" ------ 插件系统、动态配置（慎用）

✅ 推荐原则 ：优先使用 optional 和 variant，尽量避免 any，保持类型安全和性能。

这些工具极大提升了 C++ 的表达能力和安全性，是现代 C++ 编程的重要组成部分。