Union U在记忆中是什么样子的？

Question

enum Enums { k1, k2, k3, k4 };

union MYUnion { 
    struct U{ 
         char P;
    }u;

    struct U0 { 
        char state; 
    } u0; 

    struct U1 { 
        Enums e; 
        char c; 
        int v1; 
    } u1; 

    struct U2 { 
        Enums e; 
        char c; 
        int v1; 
        int v2; 
    } u2; 

    struct U3 { 
        Enums e; 
        unsigned int i; 
        char c; 
    } u3; 

    struct U4 { 
        Enums e;
        unsigned int i; 
        char c; 
        int v1; 
    } u4; 

    struct U5 { 
        Enums e; 
        unsigned int i; 
        char c; 
        int v1; 
        int v2; 
    } u5; 
} myUnion

我对 C++ 中 Union 的整个概念感到非常困惑。这个“myUnion”在记忆中是什么样子的？我知道数据共享同一个内存块，但是如何呢？尺寸是多少 “我的联盟”？如果是“u5”的大小那么这块内存中的数据是如何分配的？

Answer 1

1. 联合的大小是联合中最大事物的大小。
2. 联合的布局是您最后存储的内容。

因此，在最后一个联合中，如果您存储到 .i 中，然后存储到 .e 中，则 int 的第一个字节将被枚举值覆盖（假设sizeof (enum) 在您的环境中为 1）。

并集就像：

void * p = malloc(sizeof(biggest_item))
Enums *ep = (Enums *)e;
unsigned int * ip = (unsigned int *)p;
char *cp = (char *)p;

对 *ep、*ip 和 *cp 的赋值就像并集一样工作。

Answer 2

你感到困惑是对的！我很困惑......让我们先看一些简单的事情，然后再继续讨论更复杂的示例。

首先是工会基础知识。联合仅意味着当您创建联合类型的变量时，底层组件（在下面的示例中 i 和 f）实际上在内存中重叠。它让您有时将该内存视为 int，有时将该内存视为 float。这自然会很糟糕，你必须知道自己在做什么。

union AUnion
{
   int i;
   float f;
}; // assumes an int is 32 bits

AUnion aUnion;
aUnion.i = 0;
printf("%f", aUnion.f);

上面的代码中，会打印出什么？要理解这个问题的答案，您必须了解整数和浮点数在内存中的表示方式。两者都占用32位内存。然而，这两种类型的记忆的解释方式有所不同。当我设置 aUnion.i = 0 时，我说的是“将 0 整数写入 aUnion”。碰巧，一个 0 整数对应于将所有 32 位设置为 0。现在，当我们去打印 aUnion.f 时，我们说的是“将 aUnion 视为真正的 32 位浮点数，然后打印然后，计算机将所有这些底层位视为 float 而不是 int 的一部分。计算机知道如何将任何随机的 32 位字节视为 float，因为 它知道如何将浮点数格式化为二进制。

现在来处理一些更复杂的联合代码：

enum Enums { k1, k2, k3, k4 };

union MYUnion { 
struct U{ 
     char P;
}u;

struct U0 { 
    char state; 
} u0; 

struct U1 { 
    Enums e; 
    char c; 
    int v1; 
} u1; 

所有这些结构都以与上面的 int 和 float 相同的方式重叠。现在，如果我们假设将枚​​举映射到 int，那么我们可以将枚举映射到底层内存中的 int 值。 ，基于枚举的规则：

 enum Enums { k1/*0*/, k2/*1*/, k3/*2*/, k4/*3*/ };

那么我们所拥有的是

union MYUnion { 
struct U{ 
     char P;
}u;

struct U0 { 
    char state; 
} u0; 

struct U1 { 
    int e; 
    char c; 
    int v1; 
} u1; 

并且你有一个非常奇怪的联合 因为如果你这样做

MyUnion m;
m.u.P = 'h'

当稍后你访问枚举（很可能是一个 int ）时，它将被读取为无效价值。这是因为 P 只是 1 个字节，而 int 是 4 个字节。当读取为枚举时，您会得到奇怪的结果。

我强烈建议你解雇负责这段代码的人。

Answer 3

正如 Murali 所说，联盟的规模将是参与联盟的最大结构体的规模。

应用程序将为最大的块分配足够的字节。内存映射的工作原理如下：

考虑以下情况：

union Foo
{
  struct A
  {
    int x;
    unsigned char y;
    unsigned char z;

  }
  struct B
  {
    unsigned char a;
    unsigned char b;
    unsigned char c;
    unsigned char d;
    unsigned char e;
  }
}

在这种情况下，假设 int 是 32 位（取决于您的目标平台），a、b、c 和 d 提供对构成整数 X 的字节的访问。 A 将覆盖 x 的第一个字节，b 将覆盖 x 的第二个字节，依此类推。

相反，向 X 写入值将影响 a、b、c 和 d。

无符号字符 y 和 e 占用相同的空间（同样，取决于 int 是 32 位的事实），因此 .y 和 .e 实际上是彼此的别名。

unsigned char Az 不与结构体 B 的任何元素重叠，因此它实际上不受 B 更改的影响。

这里的要点是联合结构体的元素占用相同的内存。不同的结构体允许您使用不同的数据类型，从而提供不同的方式来读取和写入相同的内存。

Answer 4

它取决于目标 CPU 的内存模型（大-小）字节序等，以了解内存块的外观，但通常每个结构都会在同一区域上启动相同的地址和布局 -如果你知道它会做什么，那很有用，否则就是一脚射门。

Answer 5

可能是因为工会不是一个很棒的功能。它们对于您受到极大限制的内存共享可能很有用。或者不可移植的内存技巧（写入一种大小的变量并从另一种大小读取）。或者用于模仿漂亮的标记联合。

带标签的联合模式的工作原理如下。

enum mytags { FULL_TIME_WORKER, PART_TIMER, CONTRACTOR}

struct worker_t {
    enum mytags tag,
    union {
        struct full_time_worker_t full_time_wroker,
         struct part_time_worker_t part_time_worker,
         struct contractor_t contractor }
    }
}


bool person_can_do_x(worker_t w)
{
    switch(workers.tag)
    {
    case FULL_TIME_WORKER:
    ...
    case PART_TIMER:
    ...
    case CONTRACTOR:
       ...w.contractor.....
    default:
        return true
    }
}