std::variant 与 Lambda 的结合使用std::variant 和 Lambda 表达式的结合是 C++

std::variant 和 Lambda 表达式的结合是 C++17 引入的强力组合，它通过 std::visit 提供了一种类型安全、声明式的访问变体数据的方式。以下是深度解析和实用技巧：

1. 基础用法：`std::visit` + Lambda

#include <variant>
#include <iostream>

using Var = std::variant<int, float, std::string>;

void printVariant(const Var& v) {
    std::visit([](const auto& val) {  // 泛型 Lambda
        std::cout << val << "\n";    // 自动匹配类型
    }, v);
}

int main() {
    Var v1 = 42, v2 = 3.14f, v3 = "hello";
    printVariant(v1);  // 输出 42
    printVariant(v2);  // 输出 3.14
    printVariant(v3);  // 输出 hello
}

关键点：

std::visit 的第一个参数是可调用对象（如 Lambda）。
泛型 Lambda（auto 参数）会自动匹配 variant 当前存储的类型。

2. 多类型差异化处理

如果需要针对不同类型执行不同逻辑，有两种实现方式：

(1) 重载模式（C++17）

auto handler = overload{
    [](int i)    { std::cout << "int: " << i; },
    [](float f)  { std::cout << "float: " << f; },
    [](const std::string& s) { std::cout << "string: " << s; }
};

std::visit(handler, myVariant);

其中 overload 是一个辅助类（需自行定义或使用库实现）：

template<class... Ts> struct overload : Ts... { using Ts::operator()...; };
template<class... Ts> overload(Ts...) -> overload<Ts...>;  // C++17 推导指引

(2) `if constexpr`（C++17）

std::visit([](const auto& val) {
    using T = std::decay_t<decltype(val)>;
    if constexpr (std::is_same_v<T, int>) {
        std::cout << "int: " << val;
    } else if constexpr (std::is_same_v<T, float>) {
        std::cout << "float: " << val;
    } else if constexpr (std::is_same_v<T, std::string>) {
        std::cout << "string: " << val;
    }
}, myVariant);

3. 返回值处理

Lambda 可以返回统一类型或不同类型（需用 std::common_type 或 std::variant 包装）：

// 返回统一类型（如 double）
auto toDouble = [](const auto& val) -> double {
    if constexpr (std::is_arithmetic_v<decltype(val)>) {
        return static_cast<double>(val);
    } else {
        return 0.0;
    }
};
double result = std::visit(toDouble, myVariant);

// 返回变体类型
using RetVariant = std::variant<double, std::string>;
auto converter = [](const auto& val) -> RetVariant {
    if constexpr (std::is_same_v<decltype(val), std::string>) {
        return "str: " + val;
    } else {
        return static_cast<double>(val);
    }
};
RetVariant ret = std::visit(converter, myVariant);

4. 状态修改（非 const 操作）

通过非 const 引用修改 variant 的值：

std::variant<int, std::string> v = "hello";
std::visit([](auto& val) {
    if constexpr (std::is_same_v<decltype(val), std::string>) {
        val += " world";  // 修改字符串
    } else {
        val += 1;          // 修改整数
    }
}, v);

5. 结合 `std::holds_alternative` 的防御性编程

在 visit 前检查类型（虽然通常不必要，因 visit 已保证类型安全）：

if (std::holds_alternative<int>(myVariant)) {
    std::visit([](int i) { /* 仅处理 int */ }, myVariant);
}

6. 性能分析

编译期类型分发：std::visit 通常编译为高效的跳转表（类似 switch）。
对比 if-else 链：比运行时类型检查（如 std::get_if）更高效。
零额外开销：无动态分配，类型信息在编译期已知。

7. 实际应用示例

(1) 计算器支持多种输入类型

using Number = std::variant<int, float, double>;
Number add(Number a, Number b) {
    return std::visit([](auto x, auto y) -> Number {
        return x + y;  // 自动选择最大精度
    }, a, b);
}

(2) 解析 JSON 数据

using JsonValue = std::variant<std::nullptr_t, bool, int, double, std::string>;
void printJson(const JsonValue& val) {
    std::visit(overload{
        [](nullptr_t) { std::cout << "null"; },
        [](bool b)    { std::cout << (b ? "true" : "false"); },
        [](auto num)  { std::cout << num; },  // 处理所有数值类型
        [](const std::string& s) { std::cout << '"' << s << '"'; }
    }, val);
}

(3) 游戏中的事件处理

struct ClickEvent { int x, y; };
struct KeyEvent { int keyCode; };
using GameEvent = std::variant<ClickEvent, KeyEvent>;

std::vector<GameEvent> events;
for (const auto& event : events) {
    std::visit(overload{
        [](const ClickEvent& e) { /* 处理点击 */ },
        [](const KeyEvent& e)   { /* 处理按键 */ }
    }, event);
}

8. 限制与注意事项

Lambda 必须覆盖所有类型：否则编译错误。
多参数 visit：所有 variant 的类型组合必须被 Lambda 处理：
```
std::visit([](auto a, auto b) { /*...*/ }, var1, var2);
```
调试信息：Lambda 的模板实例化可能导致较长的错误信息。

总结

核心优势：类型安全 + 编译期优化 + 代码简洁。
最佳实践：
- 优先用 overload 模式处理多类型。
- 返回类型需一致或包装为 variant。
- 修改值时用非 const Lambda。
适用场景：
- 状态机
- 数据解析
- 事件处理
- 任何需要类型安全的多态操作

这种组合是现代 C++ 中替代动态多态（虚函数）的强有力工具，尤其适合性能敏感且类型明确的场景。

std::variant 与 Lambda 的结合使用

1. 基础用法：std::visit + Lambda