如何使用std::variant实现类型安全的多态？

作者

在现代 C++ 中，std::variant 成为了一种强大且类型安全的“联合体”实现，它允许一个变量持有多种预定义类型中的任意一种，并通过访问器或访问者模式来安全地使用存储的值。相比传统的 void* 或者基于继承的多态，std::variant 在编译期就能保证类型安全，并且不需要运行时的 RTTI 或动态分配，性能更好。下面我们将从几个方面来详细介绍如何使用 std::variant 实现类型安全的多态。

1. 基础用法：定义、赋值和访问

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

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

int main() {
    MyVariant v = 42;            // 赋值为 int
    std::cout << std::get<int>(v) << '\n';

    v = 3.14;                    // 赋值为 double
    std::cout << std::get<double>(v) << '\n';

    v = std::string{"hello"};    // 赋值为 string
    std::cout << std::get<std::string>(v) << '\n';

    // 访问当前持有的类型
    std::cout << "index = " << v.index() << '\n';   // 0: int, 1: double, 2: string
}
  • std::variant 在编译期就确定了可接受的类型列表。
  • `std::get (v)` 在类型不匹配时抛出 `std::bad_variant_access`，因此可以用 `try/catch` 处理异常。
  • index() 返回当前值对应的索引，方便快速判断。

2. std::visit 与访问者模式

std::visit 是对 std::variant 的核心操作，它接收一个访问者（可调用对象）和一个或多个 variant，在内部会根据每个 variant 当前持有的类型来决定调用哪个 overload。

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

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

int main() {
    MyVariant v1 = 10;
    MyVariant v2 = std::string("world");

    auto printer = [](const auto& val) {
        std::cout << val << '\n';
    };

    std::visit(printer, v1);  // 输出 10
    std::visit(printer, v2);  // 输出 world
}

访问者可以是 lambda、函数对象、甚至普通函数。如果需要处理多个 variant 同时的组合，可以写多个 overload 并利用折叠表达式实现：

auto sum = [](auto a, auto b) {
    return a + b; // 对于 string 加法会得到拼接
};

std::visit(sum, v1, v2); // 需要 v1 和 v2 的类型都能相互兼容

3. 组合 variant 与 std::optional / std::unique_ptr

在实际项目中，variant 常与 std::optional、std::unique_ptr 等类型组合使用，从而实现更复杂的数据结构。例如：

using Node = std::variant<
    std::nullptr_t,                     // 空节点
    int,                                // 整数
    std::unique_ptr <Node>,              // 子节点
    std::vector<std::unique_ptr<Node>>  // 子树集合
>;

通过递归定义，可以用 variant 来构建树形结构，而不需要显式继承。访问时同样使用 std::visit。

4. 处理异常：std::get_if 与 std::holds_alternative

若不想抛异常，可以使用 `std::get_if

(&v)` 获得指针（若类型匹配则返回非空指针），或 `std::holds_alternative(v)` 判断当前是否持有某类型。 “`cpp if (auto p = std::get_if(&v)) { std::cout `，其中 `std::monostate` 表示“空”状态。这样可以用 `has_value()` 的语义来判断是否有数据。 “`cpp using OptVariant = std::variant; OptVariant v; // 默认为 monostate if (!std::holds_alternative(v)) { std::cout (v); } “` ### 6. 与 C++20 语法糖结合 C++20 引入了 **`std::variant` 的 `std::visit` 结合 `std::pair` 的 `std::apply`**，可以让访问者更简洁： “`cpp auto visitor = [](auto&&… vals) { (… + vals); // 折叠表达式求和 }; std::visit(visitor, v1, v2); // 需要同类型或可兼容 “` ### 7. 典型案例：实现多态的“属性”系统 在游戏开发或配置管理中，经常需要存储不同类型的属性（如 health：int，name：string，position：float[3]）。使用 `std::variant` 可以让属性表保持类型安全。 “`cpp #include #include #include using Attribute = std::variant>; class PropertyMap { public: void set(const std::string& key, Attribute value) { map_[key] = std::move(value); } template T get(const std::string& key) const { const auto& v = map_.at(key); return std::get (v); } private: std::unordered_map map_; }; “` 使用示例： “`cpp PropertyMap p; p.set(“health”, 100); p.set(“name”, std::string(“Hero”)); p.set(“position”, std::array{1.0f, 2.0f, 3.0f}); int h = p.get (“health”); std::string n = p.get(“name”); auto pos = p.get>(“position”); “` ### 8. 小结 – `std::variant` 是一种类型安全的多态实现，避免了传统继承和 RTTI 的缺点。 – 通过 `std::visit` 与访问者模式，可以灵活地处理多种类型的值。 – 与 `std::optional`、`std::unique_ptr`、容器类型结合，可构建复杂的数据结构。 – 现代 C++20 语法（折叠表达式、`std::apply`）可进一步简化代码。 掌握 `std::variant` 的用法后，你将能够在不牺牲性能的前提下，以更安全、可维护的方式处理多种类型的数据。祝你编码愉快！

发表评论