Exploring the Power of std::variant in Modern C++

作者

在 C++17 之后，标准库新增了 std::variant，它提供了一种类型安全的联合（union）实现，使得我们可以在一个对象中存储多种类型中的任意一种，并在运行时安全地访问当前持有的值。与传统的 union 不同，std::variant 兼顾了构造/析构、异常安全以及类型信息的完整管理，极大地简化了许多需要多态但又不想引入继承层次的场景。

1. 基本使用

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

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

    v = 42;
    std::cout << "int: " << std::get<int>(v) << "\n";

    v = 3.14;
    std::cout << "double: " << std::get<double>(v) << "\n";

    v = std::string{"Hello, variant!"};
    std::cout << "string: " << std::get<std::string>(v) << "\n";
}

std::variant 的核心 API 包括：

  • `std::get (variant)`：访问当前持有类型为 `T` 的值，若不匹配则抛出 `std::bad_variant_access`。
  • `std::get_if (&variant)`：返回指向 `T` 的指针，如果不匹配返回 `nullptr`。
  • std::visit：通过访问者模式访问当前值，支持多种重载。

2. 访问多态值：std::visit

最常见的用法是使用 std::visit，它接受一个访问者（通常是 lambda 表达式）和一个或多个 std::variant，并在内部根据当前类型自动调用对应的重载。

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

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

    std::visit([](auto&& arg) {
        std::cout << "Value: " << arg << "\n";
    }, v);

    v = std::string{"Variant works!"};

    std::visit([](auto&& arg) {
        std::cout << "Value: " << arg << "\n";
    }, v);
}

如果需要针对不同类型做不同的处理，可以为访问者提供多重重载：

auto visitor = overload(
    [](int i)        { std::cout << "int: " << i << "\n"; },
    [](double d)     { std::cout << "double: " << d << "\n"; },
    [](const std::string& s) { std::cout << "string: " << s << "\n"; }
);
std::visit(visitor, v);

其中 overload 可以通过以下工具实现：

template<class... Ts>
struct overloaded : Ts... { using Ts::operator()...; };
template<class... Ts> overloaded(Ts...)->overloaded<Ts...>;

3. 常见场景

3.1 事件系统

在 GUI 或游戏引擎中，事件类型往往多样且属性不同。使用 std::variant 可以将所有事件包装为同一类型的容器：

struct KeyEvent { int keyCode; };
struct MouseEvent { int x, y; };
struct ResizeEvent { int width, height; };

using Event = std::variant<KeyEvent, MouseEvent, ResizeEvent>;

然后统一用 std::visit 处理。

3.2 解析器输出

编写一个简单的算术表达式解析器时，结果可能是整数、浮点数，甚至错误信息。可以返回一个 std::variant：

using ParseResult = std::variant<int, double, std::string>; // string holds error message

3.3 代替 boost::variant

在不想引入 Boost 的项目中，std::variant 已经是最优选择。其实现兼容性更好，编译器优化效果更佳。

4. 性能考量

  • std::variant 的大小等同于最大成员的大小加上额外的索引（通常是 unsigned char 或 std::size_t）。因此，成员类型不应过大或过多。
  • 访问 `std::get ` 需要进行类型检查；若使用 `std::visit`，编译器能在多态调用中进行优化，减少运行时开销。

5. 与 std::optional 的区别

std::variant 与 std::optional 的核心区别在于是否允许多种类型。若仅需要“有值/无值”的语义，std::optional 更合适；若需要在同一变量中切换多种可能类型，std::variant 则是最佳选择。

6. 代码完整示例

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

// Helper to combine lambdas
template<class... Ts>
struct overloaded : Ts... { using Ts::operator()...; };
template<class... Ts> overloaded(Ts...)->overloaded<Ts...>;

int main() {
    using Result = std::variant<int, double, std::string>;

    Result res1 = 42;
    Result res2 = 3.1415;
    Result res3 = std::string{"Error: overflow"};

    auto visitor = overloaded(
        [](int v){ std::cout << "Integer: " << v << '\n'; },
        [](double v){ std::cout << "Double: " << v << '\n'; },
        [](const std::string& v){ std::cout << "String: " << v << '\n'; }
    );

    std::visit(visitor, res1);
    std::visit(visitor, res2);
    std::visit(visitor, res3);

    // Safe access
    if (auto p = std::get_if <double>(&res2))
        std::cout << "Direct double access: " << *p << '\n';

    return 0;
}

通过上述示例，你可以看到 std::variant 在类型安全、代码可读性以及灵活性方面的巨大优势。它在现代 C++ 开发中扮演着不可或缺的角色，尤其是在需要处理多种可能数据类型但又不想使用传统继承和虚函数机制的场景中。使用 std::variant，你将获得更高效、更易维护、更符合现代编程范式的代码。

发表评论