在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;

访问位值。

你可以使用a并集，主要有两个原因:

一种以不同方式访问相同数据的方便方法，就像在您的示例中一样 当存在不同的数据成员，其中只有一个可以“活动”时，一种节省空间的方法

1实际上更像是一个c风格的黑客，在你知道目标系统的内存架构是如何工作的基础上，以捷径编写代码。就像之前所说的，如果你没有瞄准许多不同的平台，你便能够避开这一问题。我相信一些编译器可能也会让你使用打包指令(我知道他们在结构上这样做)?

2的一个很好的例子。可以在COM中广泛使用的VARIANT类型中找到。

我经常遇到的联合最常见的用法是别名。

考虑以下几点:

union Vector3f
{
  struct{ float x,y,z ; } ;
  float elts[3];
}

这有什么用?它允许通过任意名称干净利落地访问Vector3f的vec;成员:

vec.x=vec.y=vec.z=1.f ;

或者通过整数访问数组

for( int i = 0 ; i < 3 ; i++ )
  vec.elts[i]=1.f;

在某些情况下，通过名称访问是最清晰的方法。在其他情况下，特别是当以编程方式选择轴时，更简单的方法是通过数值索引访问轴- x为0,y为1,z为2。

@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无论如何都提供了相同的类型。

正如其他人提到的，联合与枚举结合并包装成结构体可用于实现带标签的联合。一个实际用途是实现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;
}

从技术上讲，它是未定义的，但实际上大多数(所有?)编译器都将其视为从一种类型使用reinterpret_cast到另一种类型，其结果是已定义的实现。我不会因为你现在的代码而失眠。