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

P粉602998670

发布时间：2025-07-01 09:47:01

514人浏览过

来源于php中文网

原创

std::variant通过类型安全和自动生命周期管理替代union并实现多态存储。1. 它在编译时进行类型检查，避免类型不安全问题；2. 自动管理对象生命周期，无需手动处理内存；3. 使用std::get或std::visit访问值，其中std::visit支持灵活的多态处理；4. 可存储基类与派生类对象或指针，结合智能指针确保内存安全；5. 相比union，std::variant更安全、可读性更好，但不支持引用类型且需处理异常。

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

现代C++的std::variant提供了一种类型安全的方式来替代union，并且可以实现多态存储，避免了union的诸多缺陷，比如类型不安全和手动管理生命周期等。std::variant允许存储不同类型的值，并在编译时进行类型检查，从而提高了代码的健壮性。

解决方案

std::variant的核心思想是创建一个可以存储多个不同类型值的类型。与union不同，std::variant知道当前存储的是哪种类型，并且可以安全地访问它。下面是如何使用std::variant来替代union，并实现多态存储的示例：

立即学习“C++免费学习笔记（深入）”；

定义variant类型：

首先，你需要定义一个std::variant，指定它可以存储的类型列表。例如，如果你想存储int、float和std::string，可以这样定义：
```
#include <variant>
#include <string>
#include <iostream>

std::variant<int, float, std::string> myVar;
```

存储值：

你可以使用赋值操作符来存储不同类型的值。std::variant会自动跟踪当前存储的类型。

myVar = 10;          // 存储一个 int
myVar = 3.14f;       // 存储一个 float
myVar = "hello";   // 存储一个 std::string

访问值：

访问std::variant中的值需要使用std::get或std::visit。std::get在编译时进行类型检查，如果类型不匹配，会抛出异常。std::visit则更加灵活，可以使用一个函数对象来处理不同的类型。

Nanonets

基于AI的自学习OCR文档处理，自动捕获文档数据

下载

使用 std::get：

try {
    int i = std::get<int>(myVar);
    std::cout << "int: " << i << std::endl;
} catch (const std::bad_variant_access& e) {
    std::cerr << "Error: " << e.what() << std::endl;
}

使用 std::visit：

std::visit([](auto&& arg){
    using T = std::decay_t<decltype(arg)>;
    if constexpr (std::is_same_v<T, int>){
        std::cout << "int: " << arg << std::endl;
    } else if constexpr (std::is_same_v<T, float>){
        std::cout << "float: " << arg << std::endl;
    } else if constexpr (std::is_same_v<T, std::string>){
        std::cout << "string: " << arg << std::endl;
    }
}, myVar);

或者更简洁的使用C++17的inline variable：

std::visit([](auto&& arg){
    if constexpr (std::is_same_v<decltype(arg), int>){
        std::cout << "int: " << arg << std::endl;
    } else if constexpr (std::is_same_v<decltype(arg), float>){
        std::cout << "float: " << arg << std::endl;
    } else if constexpr (std::is_same_v<decltype(arg), std::string>){
        std::cout << "string: " << arg << std::endl;
    }
}, myVar);

多态存储的实现：

std::variant可以存储不同类型的对象，这使得它非常适合实现多态存储。你可以将基类和派生类都放入std::variant中，然后使用std::visit来处理不同类型的对象。

#include <iostream>
#include <variant>

class Animal {
public:
    virtual void speak() {
        std::cout << "Generic animal sound" << std::endl;
    }
    virtual ~Animal() = default;
};

class Dog : public Animal {
public:
    void speak() override {
        std::cout << "Woof!" << std::endl;
    }
};

class Cat : public Animal {
public:
    void speak() override {
        std::cout << "Meow!" << std::endl;
    }
};

int main() {
    std::variant<Animal, Dog, Cat> myAnimal;

    myAnimal = Dog{};
    std::visit([](auto&& arg){
        arg.speak();
    }, myAnimal);

    myAnimal = Cat{};
    std::visit([](auto&& arg){
        arg.speak();
    }, myAnimal);

    return 0;
}

注意，这里Animal本身不是抽象类，如果Animal是抽象类，则需要存储指针。

存储指针：

如果需要存储基类指针，需要使用智能指针，以确保内存安全。

#include <iostream>
#include <variant>
#include <memory>

class Animal {
public:
    virtual void speak() {
        std::cout << "Generic animal sound" << std::endl;
    }
    virtual ~Animal() = default;
};

class Dog : public Animal {
public:
    void speak() override {
        std::cout << "Woof!" << std::endl;
    }
};

class Cat : public Animal {
public:
    void speak() override {
        std::cout << "Meow!" << std::endl;
    }
};

int main() {
    std::variant<std::unique_ptr<Animal>, std::unique_ptr<Dog>, std::unique_ptr<Cat>> myAnimal;

    myAnimal = std::make_unique<Dog>();
    std::visit([](auto&& arg){
        arg->speak();
    }, myAnimal);

    myAnimal = std::make_unique<Cat>();
    std::visit([](auto&& arg){
        arg->speak();
    }, myAnimal);

    return 0;
}