能否在不重新初始化的情况下切换std::variant当前持有的类型？

我想用std::variant实现类似C风格联合体的操作，比如下面这段C++代码的行为：

union {int a;float b;} scratch_space;
scratch_space.a = 10;
std::cout << scratch_space.b << "\n";

所有持有的对象都有默认析构函数，但执行下面的代码会抛出异常：

std::variant<int, float> v = 1;
std::cout << std::get<1>(v) << "\n";

背景补充：

• 需要实现严格类型的内存池（arena），在不同执行阶段复用同一块内存，避免过多内存分配与初始化操作。
• 流水线的每个阶段都定义一个平凡可构造/析构的结构体来规划临时内存（含布局要求等）。
• 使用普通union时遇到了可变参数模板的使用困难。

std::variant的设计目标和C风格union完全不同——它是类型安全的变体类型，会跟踪当前活跃的类型，当尝试访问非活跃类型的成员时，就会抛出std::bad_variant_access异常，这正是你遇到的问题。

如果要实现C风格union的"内存复用+类型重解释"需求，同时解决普通union的可变参数模板问题，可以用以下几种方案：

1. 手动实现可变参数的类型安全union #

利用C++的可变参数模板和内存操作，封装一个类似union的容器，支持类型重解释访问：

#include <cstddef>
#include <utility>
#include <cstring>
#include <type_traits>
#include <tuple>

template<typename... Ts>
class RawVariant {
    static_assert((std::is_trivially_destructible_v<Ts> && ...), "所有类型必须是平凡可析构的");
    alignas(Ts...) unsigned char data_[sizeof...(Ts) == 0 ? 1 : (std::max({sizeof(Ts)...}))];
public:
    // 构造任意类型的对象
    template<typename T>
    void emplace(auto&&... args) noexcept(std::is_nothrow_constructible_v<T, decltype(args)...>) {
        static_assert((std::is_same_v<T, Ts> || ...), "该类型不在变体列表中");
        // 平凡析构类型直接覆盖内存即可
        new(data_) T(std::forward<decltype(args)>(args)...);
    }

    // 重解释访问指定类型
    template<typename T>
    T& get() noexcept {
        static_assert((std::is_same_v<T, Ts> || ...), "该类型不在变体列表中");
        return *reinterpret_cast<T*>(data_);
    }

    template<typename T>
    const T& get() const noexcept {
        static_assert((std::is_same_v<T, Ts> || ...), "该类型不在变体列表中");
        return *reinterpret_cast<const T*>(data_);
    }

    // 按索引访问（类似std::variant）
    template<std::size_t I>
    auto& get() noexcept {
        using T = std::tuple_element_t<I, std::tuple<Ts...>>;
        return get<T>();
    }

    template<std::size_t I>
    const auto& get() const noexcept {
        using T = std::tuple_element_t<I, std::tuple<Ts...>>;
        return get<T>();
    }
};

使用方式：

RawVariant<int, float> v;
v.emplace<int>(10);
std::cout << v.get<float>() << "\n"; // 等价于C风格union的类型重解释

这个类的核心特性：

• 用alignas(Ts...)保证内存对齐满足所有类型要求
• 因为所有类型都是平凡析构，无需跟踪活跃类型，直接覆盖内存即可
• 支持可变参数模板，解决普通union的模板限制

2. 使用std::byte手动管理内存 #

如果不需要封装，也可以直接用std::byte数组手动实现内存复用和类型重解释：

#include <cstddef>
#include <cstring>
#include <stdexcept>
#include <type_traits>
#include <cstddef>

template<typename... Ts>
class ArenaScratch {
    static_assert((std::is_trivially_destructible_v<Ts> && ...), "所有类型必须是平凡可析构的");
    static constexpr std::size_t max_size = std::max({sizeof(Ts)...});
    static constexpr std::size_t max_align = std::max({alignof(Ts)...});
    alignas(max_align) std::byte data_[max_size];
public:
    template<typename T>
    T& as() noexcept {
        static_assert((std::is_same_v<T, Ts> || ...), "该类型不允许在临时内存中使用");
        static_assert(sizeof(T) <= max_size && alignof(T) <= max_align, "该类型无法放入临时内存");
        return *reinterpret_cast<T*>(data_);
    }

    template<typename T>
    const T& as() const noexcept {
        return const_cast<ArenaScratch*>(this)->as<T>();
    }

    // 构造对象（可选，平凡类型可直接赋值）
    template<typename T>
    void init(auto&&... args) noexcept {
        new(data_) T(std::forward<decltype(args)>(args)...);
    }
};

使用方式：

ArenaScratch<int, float> scratch;
scratch.as<int>() = 10;
std::cout << scratch.as<float>() << "\n";

3. 关键注意事项 #

• 必须确保所有类型都是平凡可构造/析构的，否则直接覆盖内存会导致未定义行为
• 类型重解释本身属于C++标准未严格定义的行为，但对于算术类型、平凡结构体，在主流编译器下的行为和C风格union一致
• 如果需要严格符合C标准，单个值的类型转换可使用C20的std::bit_cast：

  int a = 10;
  float b = std::bit_cast<float>(a);
  std::cout << b << "\n";
  

  但该方式不适合结构体的内存复用场景。

内容的提问来源于stack exchange，提问作者Eugene