在 C++ 中使用 std::variant 与 std::visit：安全的多态实现

作者

C++17 引入的 std::variant 为我们提供了一种类型安全的“联合体”，可以在同一个对象中保存多种可能的类型，而不会像传统 C 语言中的 union 那样缺少类型信息。std::variant 的强大之处在于它与 std::visit 配合使用，能够在运行时安全地访问其存储的值，并根据存储的具体类型执行不同的操作。本文将从基础使用、访问方式、访问者（visitor）设计模式以及性能注意事项等方面，系统地介绍 std::variant 与 std::visit 的使用技巧。

1. 基本语法与初始化

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

std::variant<int, double, std::string> v;

// 默认构造：存放第一个类型，即 int
v = 42;

// 直接赋值
v = 3.14;          // 存放 double
v = std::string{"hello"};   // 存放 string

std::variant 必须至少包含一种类型，且所有类型都必须满足 CopyInsertable 与 CopyAssignable 要求。若需要自定义类型，需确保实现相应的拷贝构造和赋值操作。

2. 访问与查询

2.1 std::get

int i = std::get <int>(v);          // 成功返回 int
double d = std::get <double>(v);    // 成功返回 double
// 若类型不匹配，抛出 std::bad_variant_access

若不确定类型，std::get_if 更安全：

if (auto p = std::get_if <int>(&v)) {
    std::cout << "int: " << *p << '\n';
} else {
    std::cout << "v not int\n";
}

2.2 std::holds_alternative

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

2.3 index() 与 type()

size_t idx = v.index();  // 当前索引，从 0 开始
std::cout << "variant holds type #" << idx << '\n';

3. std::visit：访问者模式

std::visit 是处理 std::variant 的核心工具。它接收一个可调用对象（函数对象、lambda 等），并根据 variant 当前持有的类型调用相应的调用体。

3.1 基本用法

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

这里使用了 泛型 lambda，auto&& 让 lambda 能接受任何类型的参数，编译器会根据 v 的类型生成相应的实例。

3.2 多个 variant

std::visit 也可以同时访问多个 variant：

std::variant<int, std::string> v1 = 10;
std::variant<double, std::string> v2 = "world";

std::visit([](auto&& a, auto&& b){
    std::cout << "a: " << a << ", b: " << b << '\n';
}, v1, v2);

编译器会生成所有可能组合的实例，保证类型安全。

3.3 自定义访问者

在复杂业务场景中，可能需要在访问时做额外的上下文判断或错误处理。可以定义一个结构体，封装多个 operator()：

struct Visitor {
    void operator()(int i) const { std::cout << "int: " << i << '\n'; }
    void operator()(double d) const { std::cout << "double: " << d << '\n'; }
    void operator()(const std::string& s) const { std::cout << "string: " << s << '\n'; }
};

std::visit(Visitor{}, v);

这样不仅代码结构更清晰，也便于维护。

4. 常见坑与注意事项

可能问题 说明 解决方案
类型擦除导致异常 `std::get
(v)若不匹配会抛出std::bad_variant_access。 | 使用std::get_if或holds_alternative` 先做检查。
性能问题 访问多次同一 variant 时，每次 std::visit 需要生成实例。 如果业务逻辑重复，考虑把访问者缓存，或直接使用 std::get_if。
复制/移动开销 std::variant 存储时需要完整拷贝/移动整个对象。 对于大型对象使用 std::shared_ptr 或 std::unique_ptr 包装。
异常安全 std::visit 的调用体若抛异常，variant 的状态保持不变。 确保访问者是 noexcept 或在异常处理中恢复状态。

5. 实战案例：实现简单的“属性容器”

假设我们需要一个属性容器，属性可以是整数、浮点数或字符串，且需要安全读取。

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

using Property = std::variant<int, double, std::string>;
class AttributeSet {
    std::unordered_map<std::string, Property> attrs_;
public:
    template<typename T>
    void set(const std::string& key, T&& value) {
        attrs_[key] = std::forward <T>(value);
    }

    template<typename T>
    T get(const std::string& key) const {
        const auto& prop = attrs_.at(key);
        return std::get <T>(prop); // 若类型不匹配抛异常
    }

    void visit(const std::string& key, auto&& visitor) const {
        std::visit(visitor, attrs_.at(key));
    }
};

int main() {
    AttributeSet a;
    a.set("age", 30);
    a.set("height", 1.78);
    a.set("name", std::string("Alice"));

    a.visit("name", [](const std::string& s){ std::cout << "Name: " << s << '\n';});
    a.visit("age", [](int i){ std::cout << "Age: " << i << '\n';});
}

此实现利用 std::variant 统一存储不同类型的数据，并通过 std::visit 对外提供安全的访问方式，既避免了传统多态的运行时开销，又保证了类型安全。

6. 小结

  • std::variant 是类型安全的“联合体”，可存储多种类型的值。
  • std::visit 负责根据当前存储的类型调用对应的访问者。
  • 与传统 union 或多态不同，variant 结合 visit 能在编译期完成类型检查，减少运行时错误。
  • 在设计大型系统时，可以用 variant 取代一些传统的 if-else 或 switch，提升代码可读性与安全性。

通过合理使用 std::variant 与 std::visit，C++ 开发者可以在保持性能的同时，编写更简洁、类型安全的代码。

发表评论