C++如何使用std::variant访问和存储不同类型

C++17引入的std::variant是一个类型安全的联合体，允许在同一个对象中存储预定义的一组类型中的任意一个值，解决了传统C++ union无法存储非平凡类型、缺乏类型安全的问题。它定义在<variant>头文件中，使用起来比自定义联合体更加方便可靠。

std::variant的基本定义与存储

使用std::variant首先需要包含对应的头文件，定义时需要指定它可以存储的所有类型，这些类型称为variant的备选项。定义完成后可以直接赋值对应类型的值，variant会自动记录当前存储的类型。

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

int main() {
    // 定义一个可以存储int、double、std::string三种类型的variant
    std::variant<int, double, std::string> var;
    
    // 存储int类型值
    var = 10;
    // 存储double类型值
    var = 3.14;
    // 存储std::string类型值
    var = "hello variant";
    
    return 0;
}

需要注意的是，std::variant的备选项类型不能是引用、数组或者void类型，同时如果备选项中有重复类型，默认情况下会优先匹配第一个出现的类型。

访问std::variant中存储的值

std::variant提供了多种访问内部值的方式，不同的方式适用场景不同，开发者可以根据需求选择合适的方法。

使用std::get访问

std::get是编译期访问方式，需要显式指定要获取的类型或者索引，如果当前variant存储的类型和指定的不匹配，会抛出std::bad_variant_access异常。

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

int main() {
    std::variant<int, double, std::string> var = "test";
    
    try {
        // 通过类型获取，当前存储的是string，获取int会抛异常
        int val1 = std::get<int>(var);
    } catch (const std::bad_variant_access& e) {
        std::cout << "获取int失败: " << e.what() << std::endl;
    }
    
    // 通过索引获取，索引从0开始，string是第三个备选项，索引为2
    std::string val2 = std::get<2>(var);
    std::cout << "获取到的值: " << val2 << std::endl;
    
    return 0;
}

使用std::get_if访问

std::get_if是 noexcept 的访问方式，它返回指向内部值的指针，如果类型不匹配则返回空指针，不会抛出异常，适合不需要异常处理的场景。

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

int main() {
    std::variant<int, double, std::string> var = 100;
    
    // 尝试获取int类型指针
    if (auto* p_int = std::get_if<int>(&var)) {
        std::cout << "int值: " << *p_int << std::endl;
    } else {
        std::cout << "当前不是int类型" << std::endl;
    }
    
    // 尝试获取string类型指针
    if (auto* p_str = std::get_if<std::string>(&var)) {
        std::cout << "string值: " << *p_str << std::endl;
    } else {
        std::cout << "当前不是string类型" << std::endl;
    }
    
    return 0;
}

使用std::visit访问

std::visit是C++17为std::variant设计的最推荐的访问方式，它支持编译期多态，通过传入一个可调用对象（通常是lambda表达式或者重载了operator()的结构体），自动根据variant当前存储的类型调用对应的处理逻辑，不需要手动判断类型，安全性和可读性都更好。

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

int main() {
    std::vector<std::variant<int, double, std::string>> vars = {10, 3.14, "hello", 20, 6.28};
    
    // 使用std::visit遍历所有variant
    for (auto& var : vars) {
        std::visit([](auto&& val) {
            using T = std::decay_t<decltype(val)>;
            if constexpr (std::is_same_v<T, int>) {
                std::cout << "int类型，值: " << val << std::endl;
            } else if constexpr (std::is_same_v<T, double>) {
                std::cout << "double类型，值: " << val << std::endl;
            } else if constexpr (std::is_same_v<T, std::string>) {
                std::cout << "string类型，值: " << val << std::endl;
            }
        }, var);
    }
    
    return 0;
}

如果需要复用的访问逻辑，也可以定义一个重载了多种类型operator()的结构体，传递给std::visit使用：

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

// 定义访问者结构体
struct Visitor {
    void operator()(int val) const {
        std::cout << "处理int: " << val * 2 << std::endl;
    }
    void operator()(double val) const {
        std::cout << "处理double: " << val * 1.5 << std::endl;
    }
    void operator()(const std::string& val) const {
        std::cout << "处理string: " << val << "_processed" << std::endl;
    }
};

int main() {
    std::variant<int, double, std::string> var = 10;
    std::visit(Visitor{}, var);
    
    var = 3.14;
    std::visit(Visitor{}, var);
    
    var = "test";
    std::visit(Visitor{}, var);
    
    return 0;
}

使用注意事项

• std::variant默认初始化时会初始化第一个备选项类型，所以如果第一个备选项没有默认构造函数，需要显式初始化，否则编译报错。
• 如果需要判断variant当前存储的类型，可以使用std::holds_alternative<T>(var)，它返回bool值表示是否存储了类型T。
• std::variant的大小是其所有备选项类型中最大的大小加上类型索引的存储开销，所以不要存放过大的对象，避免内存浪费。
• 如果variant存储的类型有共同的基类，不建议用variant替代继承多态，因为variant的备选项类型是固定的，扩展性不如继承体系。

总的来说，std::variant是C++17中非常实用的类型安全容器，合理使用可以简化很多需要存储多种类型数据的场景，减少手动类型判断的错误，提升代码的健壮性。

std::variantC++17类型存储类型访问std::visit修改时间：2026-07-15 17:12:46