C++中std::variant的使用详解和实战代码示例

std::variant 是 C++17 引入的一个类型安全的联合体（type-safe union），它可以在多个类型之间存储一个值，并在编译时进行类型检查。它是现代 C++ 类型擦除与泛型编程的核心工具之一，适用于构建可变类型结构、消息传递系统、状态机等。

一、基本概念

#include <variant>

std::variant<T1, T2, ..., Tn> v;

• 类似于联合体 union，但类型安全。
• std::variant 只能存储其中一个类型的值。
• 默认构造时，会初始化为第一个类型的默认值。

二、核心操作

1. 构造与赋值

#include <iostream>
#include <variant>

int main() {
    std::variant<int, std::string> v;

    v = 42;                 // 存储 int
    std::cout << std::get<int>(v) << std::endl;

    v = "hello";            // 存储 string
    std::cout << std::get<std::string>(v) << std::endl;

    return 0;
}

2. 访问值：std::get<T>() 或 std::get<index>()

std::get<int>(v);              // 根据类型访问
std::get<0>(v);                // 根据索引访问（int 是第 0 个类型）

如果类型不匹配，将抛出 std::bad_variant_access 异常。

3. 判断当前存储的类型

if (std::holds_alternative<std::string>(v)) {
    std::cout << "v contains a string\n";
}

4. 获取当前类型索引

std::cout << "index = " << v.index() << std::endl;

三、使用 std::visit 实现模式匹配

#include <iostream>
#include <variant>

void printVariant(const std::variant<int, std::string>& v) {
    std::visit([](auto&& arg) {
        std::cout << "Value: " << arg << std::endl;
    }, v);
}

四、完整示例：表达式计算器

#include <iostream>
#include <variant>
#include <vector>

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

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

int main() {
    std::vector<Expr> exprs = { 1, 3.14f, "hello" };

    for (const auto& e : exprs)
        processExpr(e);

    return 0;
}

五、进阶用法：递归类型（std::monostate + std::unique_ptr）

std::variant 不能直接定义递归类型（自身包含自身）。需要使用指针 + std::monostate：

struct Node;

using Tree = std::variant<
    std::monostate,        // 空节点
    int,                   // 叶子
    std::unique_ptr<Node>  // 子树
>;

struct Node {
    Tree left;
    Tree right;
};

六、注意事项

七、综合实战示例

下面是一个用 std::variant 实现的 有限状态机（FSM）+ 消息分发系统 的综合示例，适用于状态驱动的系统，如游戏角色状态、UI 状态、网络连接状态等。

示例目的结构

我们实现一个简单的 FSM：角色可以在 Idle, Moving, Attacking 三个状态间切换，接收 Message 控制状态转换。

1. 基础定义

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

// 状态定义
struct Idle {};
struct Moving { std::string destination; };
struct Attacking { std::string target; };

// 消息定义
struct StartMoving { std::string destination; };
struct StopMoving {};
struct StartAttack { std::string target; };
struct StopAttack {};

// 状态类型和消息类型
using State = std::variant<Idle, Moving, Attacking>;
using Message = std::variant<StartMoving, StopMoving, StartAttack, StopAttack>;

2. 消息处理器（核心）

void handle_message(State& state, const Message& msg) {
    std::visit([&](auto&& current_state) {
        using Current = std::decay_t<decltype(current_state)>;

        std::visit([&](auto&& m) {
            using Msg = std::decay_t<decltype(m)>;

            if constexpr (std::is_same_v<Current, Idle>) {
                if constexpr (std::is_same_v<Msg, StartMoving>) {
                    std::cout << "Idle → Moving to " << m.destination << "\n";
                    state = Moving{m.destination};
                } else if constexpr (std::is_same_v<Msg, StartAttack>) {
                    std::cout << "Idle → Attacking " << m.target << "\n";
                    state = Attacking{m.target};
                }
            } else if constexpr (std::is_same_v<Current, Moving>) {
                if constexpr (std::is_same_v<Msg, StopMoving>) {
                    std::cout << "Moving → Idle\n";
                    state = Idle{};
                } else if constexpr (std::is_same_v<Msg, StartAttack>) {
                    std::cout << "Moving → Attacking " << m.target << "\n";
                    state = Attacking{m.target};
                }
            } else if constexpr (std::is_same_v<Current, Attacking>) {
                if constexpr (std::is_same_v<Msg, StopAttack>) {
                    std::cout << "Attacking → Idle\n";
                    state = Idle{};
                } else if constexpr (std::is_same_v<Msg, StartMoving>) {
                    std::cout << "Attacking → Moving to " << m.destination << "\n";
                    state = Moving{m.destination};
                }
            }
        }, msg);
    }, state);
}

3. 主程序（状态切换测试）

int main() {
    State state = Idle{};

    handle_message(state, StartMoving{"North"});
    handle_message(state, StartAttack{"Dragon"});
    handle_message(state, StopAttack{});
    handle_message(state, StartAttack{"Goblin"});
    handle_message(state, StartMoving{"East"});
    handle_message(state, StopMoving{});

    return 0;
}

输出示例：

Idle → Moving to North
Moving → Attacking Dragon
Attacking → Idle
Idle → Attacking Goblin
Attacking → Moving to East
Moving → Idle

小结：此结构的优势

总结