@bobobobo代码是正确的，正如@Joshua指出的那样(遗憾的是，我不允许添加注释，所以在这里做，IMO不允许它放在第一位的坏决定):

https://en.cppreference.com/w/cpp/language/data_members#Standard_layout告诉我们这样做是可以的，至少从c++ 14开始

在具有非并集类类型T1的活动成员的标准布局联合中，允许读取另一个非并集类类型T2的联合成员的非静态数据成员m，前提是m是T1和T2的公共初始序列的一部分(除非通过非易失性glvalue读取易失性成员是未定义的)。

因为在当前的情况下T1和T2无论如何都提供了相同的类型。

在C语言中，这是实现像变体这样的东西的好方法。

enum possibleTypes{
  eInt,
  eDouble,
  eChar
}


struct Value{

    union Value {
      int iVal_;
      double dval;
      char cVal;
    } value_;
    possibleTypes discriminator_;
} 

switch(val.discriminator_)
{
  case eInt: val.value_.iVal_; break;

在内存较少的情况下，此结构体比具有所有成员的结构体使用更少的内存。

顺便说一下，C提供了

    typedef struct {
      unsigned int mantissa_low:32;      //mantissa
      unsigned int mantissa_high:20;
      unsigned int exponent:11;         //exponent
      unsigned int sign:1;
    } realVal;

访问位值。

在c++中，Boost Variant实现了一个安全的联合版本，旨在尽可能地防止未定义的行为。

它的性能与enum + union结构相同(也分配了堆栈等)，但它使用类型的模板列表而不是enum:)

正如其他人提到的，联合与枚举结合并包装成结构体可用于实现带标签的联合。一个实际用途是实现Rust的Result<T, E>，它最初是使用纯枚举实现的(Rust可以在枚举变量中保存额外的数据)。下面是一个c++的例子:

template <typename T, typename E> struct Result {
    public:
    enum class Success : uint8_t { Ok, Err };
    Result(T val) {
        m_success = Success::Ok;
        m_value.ok = val;
    }
    Result(E val) {
        m_success = Success::Err;
        m_value.err = val;
    }
    inline bool operator==(const Result& other) {
        return other.m_success == this->m_success;
    }
    inline bool operator!=(const Result& other) {
        return other.m_success != this->m_success;
    }
    inline T expect(const char* errorMsg) {
        if (m_success == Success::Err) throw errorMsg;
        else return m_value.ok;
    }
    inline bool is_ok() {
        return m_success == Success::Ok;
    }
    inline bool is_err() {
        return m_success == Success::Err;
    }
    inline const T* ok() {
        if (is_ok()) return m_value.ok;
        else return nullptr;
    }
    inline const T* err() {
        if (is_err()) return m_value.err;
        else return nullptr;
    }

    // Other methods from https://doc.rust-lang.org/std/result/enum.Result.html

    private:
    Success m_success;
    union _val_t { T ok; E err; } m_value;
}

结合的目的是相当明显的，但由于某种原因，人们经常忽略它。

联合的目的是通过使用相同的内存区域在不同的时间存储不同的对象来节省内存。就是这样。

它就像旅馆里的一个房间。不同的人住在里面的时间不重叠。这些人从来没有见过面，而且通常对彼此一无所知。通过合理管理房间的分时(即确保不同的人不会同时被分配到一个房间)，一个相对较小的酒店可以为相对大量的人提供住宿，这就是酒店的目的。

这正是工会所做的。如果您知道程序中的几个对象所保存的值具有不重叠的值生存期，那么您可以将这些对象“合并”为一个联合，从而节省内存。就像酒店房间在每个时刻最多有一个“活跃”租户一样，工会在每个节目时间最多有一个“活跃”成员。只能读取“活动”成员。通过写入其他成员，您将“活动”状态切换到其他成员。

出于某种原因，联合的最初目的被完全不同的东西“覆盖”了:写联合的一个成员，然后通过另一个成员检查它。这种内存重解释(又名“类型双关语”)不是联合的有效使用。它通常会导致未定义的行为，在C89/90中被描述为产生实现定义的行为。

编辑:在C99标准的一个技术勘误表(参见DR#257和DR#283)中，为了类型双关的目的而使用联合(即写入一个成员，然后读取另一个成员)给出了更详细的定义。但是，请记住，在形式上，这并不能防止您在试图读取陷阱表示时遇到未定义的行为。

正如你所说，这是严格未定义的行为，尽管它将“工作”在许多平台上。使用联合的真正原因是为了创建不同的记录。

union A {
   int i;
   double d;
};

A a[10];    // records in "a" can be either ints or doubles 
a[0].i = 42;
a[1].d = 1.23;

当然，您还需要某种鉴别器来说明这个变体实际上包含了什么。注意，在c++中，联合的用处不大，因为它们只能包含POD类型——实际上是那些没有构造函数和析构函数的类型。