C++17 中的 std::variant 用法与常见陷阱

作者

在 C++17 标准中，std::variant 被引入为一种类型安全的联合体，能够在同一个对象中存放多种类型之一。它与传统的 std::union 和 boost::variant 相比，提供了更为现代、类型安全且易于使用的接口。本文将从基本使用、访问方式、类型检查以及常见陷阱四个方面，深入剖析 std::variant 的实战技巧。

1. 基本声明与初始化

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

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

int main() {
    MyVar v1 = 42;              // 隐式转换为 int
    MyVar v2 = 3.14;            // 隐式转换为 double
    MyVar v3 = std::string{"hello"}; // 隐式转换为 string
    MyVar v4 = 1;               // 也可以显式写成 MyVar v4{1};
}

注意，variant 的模板参数必须是唯一且不相互继承的类型，且每个类型都需要满足可复制或可移动（CopyConstructible/MoveConstructible）的要求。

2. 访问存储值

2.1 std::get

int i = std::get <int>(v1);       // 取出 int
double d = std::get <double>(v2); // 取出 double
std::string s = std::get<std::string>(v3); // 取出 string

如果索引或类型不匹配，会抛出 std::bad_variant_access 异常。

2.2 std::get_if

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

get_if 在类型匹配成功时返回指针，失败返回 nullptr，因此避免了异常开销。

2.3 std::visit

std::visit 能够对当前存储的类型执行不同的操作，利用可调用对象的重载实现多态行为。

auto visitor = [](auto&& arg) {
    using T = std::decay_t<decltype(arg)>;
    if constexpr (std::is_same_v<T, int>) {
        std::cout << "int: " << arg << '\n';
    } else if constexpr (std::is_same_v<T, double>) {
        std::cout << "double: " << arg << '\n';
    } else {
        std::cout << "string: " << arg << '\n';
    }
};

std::visit(visitor, v1);
std::visit(visitor, v3);

visit 的返回值由可调用对象的返回类型决定，且可配合 std::variant 的 holds_alternative 来判断当前类型。

3. 类型检查与状态

  • v.index() 返回当前存储值的索引，从 0 开始。若未初始化（使用 std::variant 的默认构造），索引为 ，对应模板参数列表中的第一个类型。
  • v.valueless_by_exception() 判断在异常情况下对象是否失去值。默认构造的 variant 在异常中保持值（如果构造不抛异常），但若构造抛异常后会进入无值状态。
  • `holds_alternative (v)` 用于检查当前是否为 `T` 类型。

4. 赋值与交换

MyVar v = 42;
v = 3.14; // 自动切换到 double
v = std::string{"world"}; // 切换到 string

MyVar v2 = std::string{"foo"};
std::swap(v, v2); // 互换

若赋值过程中抛异常，variant 会保持原始值，不进入无值状态（前提是被赋值类型的构造/移动不会抛异常）。

5. 常见陷阱

陷阱 说明 解决方案
类型顺序影响默认构造 默认构造的 variant 会初始化为第一个类型的值。若第一个类型不适合当前业务，可能导致意外行为。 在声明时使用 std::variant<std::monostate, ...>，将 std::monostate 放在首位，让对象默认无值。
get_if 的地址失效 `std::get_if
(&v)返回指向内部值的指针，若variant` 发生移动或重新赋值，指针会失效。 在使用后立即拷贝值或避免跨越可能导致移动的操作。
异常安全 variant 的赋值如果被赋值类型的构造/移动抛异常，variant 会进入无值状态。 确保被赋值类型的构造/移动操作满足 noexcept，或使用 try/catch 处理。
多继承与多重类型 variant 的模板参数不能是相互继承的类型，否则编译错误。 检查类型继承关系，必要时使用 std::variant<std::variant<T1, T2>, T3> 等嵌套方式。
缺乏 operator== std::variant 在 C++20 才添加了 operator==；旧标准下需要自己实现比较。 若需要比较，手动实现或使用 std::visit。
隐式转换冲突 当 variant 的类型列表中存在可转换关系（如 int 与 long），std::variant<int, long> 对赋值时会报编译错误。 用显式构造或在列表中排除冲突类型，或使用 std::variant<int, std::int64_t> 等完全不兼容的类型。
std::variant 与 std::any 的混淆 variant 是类型安全的多态，编译期决定类型；any 是运行时多态。 根据需要选择使用哪一种。
错误的 std::visit 调用 在 visit 的可调用对象中忘记返回值，导致未定义行为。 确保 visit 的返回类型一致或使用 void 返回。

6. 进阶使用：自定义 variant 结构

struct Point { double x, y; };
struct Color { unsigned r, g, b; };

using VarData = std::variant<int, double, std::string, Point, Color>;

int main() {
    VarData d = Point{1.0, 2.0};
    std::visit([](auto&& arg) {
        using T = std::decay_t<decltype(arg)>;
        if constexpr (std::is_same_v<T, Point>) {
            std::cout << "Point(" << arg.x << ", " << arg.y << ")\n";
        } else if constexpr (std::is_same_v<T, Color>) {
            std::cout << "Color(" << arg.r << ", " << arg.g << ", " << arg.b << ")\n";
        }
    }, d);
}

通过将自定义类型加入 variant，即可轻松在统一接口下处理多种数据结构。

7. 小结

std::variant 是 C++17 引入的强大工具，为需要存储多种类型的场景提供了类型安全且高效的解决方案。掌握其基本语法、访问模式与异常安全策略，能够避免常见陷阱，让代码既优雅又可靠。随着标准的演进，variant 还将继续得到扩展（如 std::monostate 的更广泛使用、std::visit 的更灵活实现等），值得在日常项目中积极引入。

发表评论