296

我之前很舒服地使用了工会；今天当我看到这篇文章并知道这段代码时我很震惊

union ARGB
{
    uint32_t colour;

    struct componentsTag
    {
        uint8_t b;
        uint8_t g;
        uint8_t r;
        uint8_t a;
    } components;

} pixel;

pixel.colour = 0xff040201;  // ARGB::colour is the active member from now on

// somewhere down the line, without any edit to pixel

if(pixel.components.a)      // accessing the non-active member ARGB::components

实际上是未定义的行为，即从最近写入的联合成员之外的成员读取会导致未定义的行为。如果这不是联合的预期用途，那是什么？有人可以详细解释一下吗？

更新：

我想在事后澄清一些事情。

  • 对于 C 和 C++，这个问题的答案是不一样的。我无知的年轻自我将其标记为 C 和 C++。
  • 在浏览了 C++11 的标准之后，我不能确定地说它调用访问/检查非活动联合成员是未定义/未指定/实现定义的。我只能找到§9.5/1：

    如果标准布局联合包含多个共享公共初始序列的标准布局结构，并且此标准布局联合类型的对象包含标准布局结构之一，则允许检查任何标准布局的公共初始序列标准布局结构成员。§9.2/19：两个标准布局结构共享一个共同的初始序列，如果相应的成员具有布局兼容的类型，并且两个成员都不是位域或两者都是一个或多个初始序列的具有相同宽度的位域成员。

  • 在 C 语言中（C99 TC3 - DR 283起）这样做是合法的（感谢 Pascal Cuoq提出这个问题）。但是，如果读取的值恰好对于它所读取的类型无效（所谓的“陷阱表示”），那么尝试这样做仍然会导致未定义的行为。否则，读取的值是实现定义的。

  • C89/90 在未指定的行为（附件 J）下指出了这一点，K&R 的书说它是定义的实现。来自 K&R 的报价：

    这就是联合的​​目的——一个可以合法地持有几种类型中的任何一种的单一变量。[...] 只要用法一致：检索到的类型必须是最近存储的类型。程序员有责任跟踪当前存储在联合中的类型；如果将某些内容存储为一种类型并提取为另一种类型，则结果取决于实现。

  • 摘自 Stroustrup 的 TC++PL（重点是我的）

    联合的使用对于数据的兼容性可能是必不可少的 [...]有时误用于“类型转换”。

最重要的是，提出这个问题（自我问起，其标题保持不变）的目的是了解联合的目的，而不是标准允许的内容。例如，C++ 标准当然允许使用继承进行代码重用，但是这不是将继承作为 C++ 语言特性引入的目的或初衷。这就是安德烈的答案继续被接受的原因。

4

16 回答 16

491

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

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

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

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

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

编辑：使用联合用于类型双关语（即写一个成员然后读另一个成员）在 C99 标准的技术勘误之一中给出了更详细的定义（参见DR#257和DR#283）。但是，请记住，形式上这并不能保护您免于尝试读取陷阱表示而陷入未定义的行为。

于 2010-02-22T19:52:02.693 回答
42

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

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

    union
    {
        int intValue;
        double dblValue;
        char *strValue;
    } value;
} object;
于 2010-02-22T11:24:30.153 回答
34

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

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

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

于 2010-02-22T11:28:27.810 回答
26

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

考虑以下：

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

这是做什么的？它允许通过任一名称干净、整洁地访问 aVector3f 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。

于 2013-08-11T22:43:16.527 回答
10

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

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

于 2010-02-22T11:22:20.970 回答
8

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

访问位值。

于 2010-02-22T12:10:35.930 回答
5

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

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

于 2010-02-22T13:09:57.743 回答
5

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

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

于 2012-01-18T11:21:31.557 回答
5

尽管这是严格未定义的行为，但实际上它几乎可以与任何编译器一起使用。它是如此广泛使用的范式，以至于任何自尊的编译器都需要在这种情况下做“正确的事情”。它肯定比类型双关语更受欢迎，它很可能会使用某些编译器生成损坏的代码。

于 2010-02-22T11:22:40.500 回答
4

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

于 2010-02-22T19:42:18.473 回答
4

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

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

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

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

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

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

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

于 2010-02-22T14:25:14.327 回答
4

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

于 2010-02-22T11:49:28.527 回答
4

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

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

于 2016-09-21T16:24:32.927 回答
3

正如其他人提到的，联合与枚举结合并包装到结构中可用于实现标记联合。一个实际用途是实现 Rust 的Result<T, E>，它最初是使用 pure 实现的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;
}
于 2019-05-27T16:16:10.353 回答
2

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

  1. 一种以不同方式访问相同数据的便捷方法，例如您的示例
  2. 当有不同的数据成员，其中只有一个可以“活动”时，一种节省空间的方法

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

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

于 2010-02-22T11:46:30.353 回答
0

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

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

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

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

于 2020-10-05T13:49:29.423 回答