现代C++的std::variant怎么替代union实现类型安全的多态存储

传统C++中的union类型允许在相同的内存位置存储不同的数据类型，但它存在明显的局限性：无法进行类型安全检查，存储非平凡类型（如带有构造析构函数的类）时行为未定义，还需要开发者手动记录当前存储的实际类型。现代C++引入的std::variant完美解决了这些问题，它不仅能安全存储多种类型，还支持类型安全的访问操作，是替代union的最佳选择。

传统union的痛点

传统union的使用需要开发者自行维护当前存储的类型，稍有不慎就会出现未定义行为，以下是传统union的典型问题：

• 无类型安全保障：访问union成员时不会检查当前实际存储的类型，访问错误成员会导致数据错误甚至程序崩溃
• 无法存储非平凡类型：union不能存储带有自定义构造、析构、拷贝函数的类类型，限制了使用场景
• 需要手动管理类型标记：通常需要配合一个额外的变量记录当前存储的类型，增加了代码复杂度

下面是一个传统union的使用示例，需要手动维护类型标记：

#include <iostream>
#include <string>

union Data {
    int intVal;
    float floatVal;
    // 不能存储std::string这样的非平凡类型，会编译报错
};

enum class DataType {
    INT,
    FLOAT
};

int main() {
    Data data;
    DataType currentType = DataType::INT;
    data.intVal = 10;
    // 如果忘记更新currentType，后续访问就会出错
    if (currentType == DataType::INT) {
        std::cout << data.intVal << std::endl;
    }
    return 0;
}

std::variant的核心特性

std::variant是定义于<variant>头文件中的模板类，它可以存储指定类型列表中的任意一个类型的值，并且自带类型信息，核心特性如下：

• 类型安全：内部会记录当前存储的实际类型，访问时会进行类型检查
• 支持非平凡类型：可以存储带有构造析构函数的类类型，会自动管理生命周期
• 丰富的访问接口：提供了std::get、std::get_if、std::visit等多种安全访问方式
• 编译期类型检查：类型列表在编译期确定，无法存储列表外的类型

用std::variant替代union的基础用法

使用std::variant替代传统union非常简单，只需要将union支持的类型列表作为模板参数传入即可，以下是基础使用示例：

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

// 定义variant支持的类型列表，可以包含非平凡类型std::string
using MyVariant = std::variant<int, float, std::string>;

int main() {
    MyVariant var;
    // 默认初始化为第一个类型的值
    std::cout << "默认存储的类型索引: " << var.index() << std::endl;
    
    // 赋值不同类型的值
    var = 10;
    std::cout << "当前存储int值: " << std::get<int>(var) << std::endl;
    
    var = 3.14f;
    std::cout << "当前存储float值: " << std::get<float>(var) << std::endl;
    
    var = "hello variant";
    std::cout << "当前存储string值: " << std::get<std::string>(var) << std::endl;
    
    return 0;
}

上述代码中，var.index()可以返回当前存储类型的索引，std::get<T>可以获取指定类型的值，如果当前存储的类型不是T，会抛出std::bad_variant_access异常。

std::variant的安全访问方式

为了避免访问时抛出异常，std::variant提供了多种安全的访问方式，适配不同的使用场景：

1. 使用std::get_if访问

std::get_if会返回一个指向存储值的指针，如果类型不匹配则返回空指针，不会抛出异常：

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

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

int main() {
    MyVariant var = 10;
    // 尝试获取int类型的值
    if (auto* pInt = std::get_if<int>(&var)) {
        std::cout << "获取到int值: " << *pInt << std::endl;
    } else {
        std::cout << "当前存储的不是int类型" << std::endl;
    }
    
    // 尝试获取string类型的值
    if (auto* pStr = std::get_if<std::string>(&var)) {
        std::cout << "获取到string值: " << *pStr << std::endl;
    } else {
        std::cout << "当前存储的不是string类型" << std::endl;
    }
    return 0;
}

2. 使用std::visit访问

std::visit是std::variant最强大的访问方式，它接受一个访问者对象和variant实例，会根据当前存储的类型自动调用对应的处理函数，非常适合实现多态逻辑：

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

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

// 定义访问者结构体，重载operator()处理不同类型
struct Visitor {
    void operator()(int val) const {
        std::cout << "处理int类型，值: " << val << std::endl;
    }
    void operator()(float val) const {
        std::cout << "处理float类型，值: " << val << std::endl;
    }
    void operator()(const std::string& val) const {
        std::cout << "处理string类型，值: " << val << std::endl;
    }
};

int main() {
    MyVariant var1 = 10;
    MyVariant var2 = 3.14f;
    MyVariant var3 = "test";
    
    std::visit(Visitor{}, var1);
    std::visit(Visitor{}, var2);
    std::visit(Visitor{}, var3);
    return 0;
}

用std::variant实现类型安全的多态存储

传统实现多态通常需要使用基类指针配合虚函数，这种方式需要动态内存分配，并且容易出现内存泄漏。使用std::variant配合std::visit可以实现类型安全的静态多态，无需动态内存分配，性能更好。

比如我们需要处理多种形状的计算面积逻辑，传统方式需要定义基类Shape和派生类Circle、Rectangle，而使用std::variant可以这样实现：

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

// 定义圆形结构体
struct Circle {
    double radius;
    double area() const {
        return M_PI * radius * radius;
    }
};

// 定义矩形结构体
struct Rectangle {
    double width;
    double height;
    double area() const {
        return width * height;
    }
};

// 定义三角形结构体
struct Triangle {
    double base;
    double height;
    double area() const {
        return 0.5 * base * height;
    }
};

// 定义形状variant类型，包含所有形状类型
using Shape = std::variant<Circle, Rectangle, Triangle>;

// 定义面积计算访问者
struct AreaCalculator {
    double operator()(const Circle& c) const {
        return c.area();
    }
    double operator()(const Rectangle& r) const {
        return r.area();
    }
    double operator()(const Triangle& t) const {
        return t.area();
    }
};

int main() {
    // 存储不同类型的形状，无需动态内存分配
    Shape shape1 = Circle{2.0};
    Shape shape2 = Rectangle{3.0, 4.0};
    Shape shape3 = Triangle{5.0, 6.0};
    
    // 计算面积，类型安全，无需虚函数
    std::cout << "圆形面积: " << std::visit(AreaCalculator{}, shape1) << std::endl;
    std::cout << "矩形面积: " << std::visit(AreaCalculator{}, shape2) << std::endl;
    std::cout << "三角形面积: " << std::visit(AreaCalculator{}, shape3) << std::endl;
    
    return 0;
}

这种实现方式的所有类型在编译期就确定，不存在运行时类型转换的风险，也不需要管理堆内存，比传统虚函数多态更安全高效。

std::variant的注意事项

• std::variant不能存储引用类型、数组类型，也不能存储当前variant自身（避免递归定义）
• 如果variant的类型列表中包含重复类型，编译会报错
• 当variant存储的类型有共同的构造参数时，需要注意构造函数的匹配规则，避免歧义
• 如果variant的所有类型都有对应的移动构造/移动赋值函数，variant的移动操作会调用对应类型的移动操作，效率较高

综上，std::variant完全覆盖了传统union的使用场景，并且提供了类型安全、支持非平凡类型、无需手动管理类型标记等优势，是现代C++中替代union的最佳选择，尤其适合需要实现类型安全多态存储的场景。

std_variantunion类型安全多态存储C++修改时间：2026-07-18 11:57:41