和 C++ 中联合的用途

工会的目的很明显，但由于某种原因，人们经常错过它。

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

这就像酒店的房间。不同的人在其中生活的时间不重叠。这些人从不见面，而且通常对彼此一无所知。通过适当管理房间的分时（即确保不同的人不会同时被分配到一个房间），一个相对较小的酒店可以为相对大量的人提供住宿，这就是酒店是给。

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

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

编辑： 在 C99 标准的技术勘误之一中给出了更详细的定义（参见 DR#257 和 { 2}）。但是，请记住，形式上这并不能保护您免于尝试读取陷阱表示而陷入未定义的行为。

---

您可以使用联合来创建如下所示的结构，其中包含一个告诉我们实际使用联合的哪个组件的字段：

struct VAROBJECT
{
    enum o_t { Int, Double, String } objectType;

    union
    {
        int intValue;
        double dblValue;
        char *strValue;
    } value;
} object;

---

从语言的角度来看，行为是未定义的。考虑到不同的平台在内存对齐和字节序方面可能有不同的约束。大端与小端机器中的代码将以不同的方式更新结构中的值。修复语言中的行为将需要所有实现使用相同的字节序（和内存对齐约束......）限制使用。

如果您使用的是 C++（您使用的是两个标签）并且您真的关心可移植性，那么您可以只使用该结构并提供一个获取 uint32_t 并通过位掩码操作适当地设置字段的设置器。同样可以在 C 中使用函数来完成。

编辑：我期待 AProgrammer 写下投票的答案并关闭这个答案。正如一些评论所指出的，字节序在标准的其他部分通过让每个实现决定做什么来处理，对齐和填充也可以不同地处理。现在，AProgrammer 隐式引用的严格别名规则在这里很重要。允许编译器对变量的修改（或未修改）做出假设。在联合的情况下，编译器可以重新排序指令并将每个颜色组件的读取移动到对颜色变量的写入。

---

我经常遇到的 union 最常见的用法是aliasing。

考虑以下：

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

这是做什么的？它允许通过 either 名称对 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。

---

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

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 类型——实际上是那些没有构造函数和析构函数的类型。

---

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

在 litlle memory 的时候，这个结构使用的内存比拥有所有成员的结构要少。

顺便说一句，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 :)

---

行为可能是未定义的，但这只是意味着没有“标准”。所有体面的编译器都提供 #pragmas 来控制打包和对齐，但可能有不同的默认值。默认值也会根据使用的优化设置而改变。

此外，联合不只是 是为了节省空间。它们可以帮助现代编译器进行类型双关。如果您reinterpret_cast<> 编译器无法对您在做什么做出假设。它可能不得不丢弃它所知道的关于您的类型的信息并重新开始（强制写回内存，与 CPU 时钟速度相比，这在当今是非常低效的）。

---

从技术上讲，它是未定义的，但实际上大多数（全部？）编译器将其视为使用从一种类型到另一种类型的 reinterpret_cast 完全相同，其结果是实现定义的。我不会因为您当前的代码而失眠。

---

对于联合实际使用的另一个示例，CORBA 框架使用标记联合方法序列化对象。所有用户定义的类都是一个（巨大的）联合的成员，integer identifier 告诉 demarshaller 如何解释联合。

---

其他人提到了架构差异（小 - 大端）。

我读到的问题是，由于变量的内存是共享的，因此通过写入一个变量，其他变量会发生变化，并且根据它们的类型，值可能毫无意义。

例如。联合{浮动f;诠释我; } X;

如果您随后从 xf 读取，写入 xi 将毫无意义 - 除非您打算这样做以查看浮点数的符号、指数或尾数分量。

我认为还有一个对齐问题：如果某些变量必须是字对齐的，那么您可能不会得到预期的结果。

例如。联合{ char c[4];诠释我; } X;

如果，假设，在某些机器上一个 char 必须是字对齐的，那么 c[0] 和 c[1] 将与 i 共享存储，但不与 c[2] 和 c[3] 共享存储。

---

在 1974 年的 C 语言中，所有结构成员共享一个公共命名空间，“ptr->member”的含义被定义为将成员的位移添加到“ptr”并使用成员的类型访问结果地址。这种设计使得可以使用相同的ptr，其成员名称取自不同的结构定义但具有相同的偏移量；程序员将这种能力用于各种目的。

当结构成员被分配了自己的命名空间时，就不可能声明两个具有相同位移的结构成员。在语言中添加联合使得实现与该语言早期版本中可用的相同语义成为可能（尽管无法将名称导出到封闭上下文可能仍然需要使用查找/替换来替换 foo->member进入 foo->type1.member)。重要的不是添加联合的人有任何特定的目标用法，而是它们提供了一种方法，使依赖早期语义的程序员，无论出于何种目的，仍然应该能够实现即使他们必须使用不同的语法来执行相同的语义。

---

正如其他人提到的，联合与枚举结合并包装到结构中可用于实现标记联合。一种实际用途是实现 Rust 的 Result<T, E>，它最初是使用纯 enum 实现的（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;
}

---

您可以使用 aa union 有两个主要原因：

一种以不同方式访问相同数据的便捷方式，例如在您的示例中

实际上更像是一种 C 风格的 hack，在您了解目标系统的内存架构如何工作的基础上，可以快捷地编写代码。如前所述，如果您实际上不针对许多不同的平台，通常可以侥幸逃脱。我相信一些编译器也可能让你使用打包指令（我知道他们在结构上做）？

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

---

@bobobobo 代码是正确的，正如@Joshua 指出的那样（遗憾的是我不允许添加评论，所以在这里这样做，IMO 错误的决定首先禁止它）：

https://en.cppreference.com/w/cpp/language/data_members#Standard_layout 表明这样做是可以的，至少从 C++14 开始

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

因为在当前情况下，T1 和 T2 无论如何都捐赠相同的类型。

---