C 中的联合内存共享

Question

Edit2：我可以用 Union 进行多态吗？在我看来，我可以根据我的需要更改数据结构。

编辑：修复代码。使用 ”。”而不是“->”。我想问的是，当存在不同的数据类型时（例如 int 和 char 互换使用）如何确保值正确存储？由于两者的内存大小不同，需要更大内存空间的将为两者分配内存空间 据

假设我有 2 个结构体：

typedef struct a{
          int a;
}aType;

typedef struct b{
          char b;
}bType;

typedef union{
         aType a_type;
         bType b_type;
}ab;

int main(void){
         ab v1;
         v1.a_type.a = 5;
         v1.b_type.b = 'a'
}

我所知，aType 和 bType 将共享相同的内存，因为 int 多了 3 个字节（int 是 4 个字节，char 是 1 个字节），因此它有4 个内存块。第一个是最左边的，最后一个是最右边的。当我将“a”分配给 v1 的变量 b 时，它将保留在内存块的第一个块（最左边）中。值5仍然保留在第四块内存中（最右边），

因此，当打印出来时，它会产生垃圾值，不是吗？如果是这样，如何解决这个问题？我将“a”存储到b_type中，共享内存必须确保只有该值“a”，而不是之前的整数值5。

Answer 1

解决此问题的唯一方法是跟踪您存储的数据。这通常是使用所谓的标签成员来完成的，如下所示：

struct mystructA {
    int data;
};
struct mystructB {
    char data;
};
enum data_tag {
    TAG_STRUCT_A,
    TAG_STRUCT_B
};
struct combined {
    enum data_tag tag;
    union {
        struct mystructA value_a;
        struct mystructA value_b;
    } data;
};

通过仔细跟踪您输入的数据，您可以确保稍后只读取相同的字段，从而确保您获得有意义的结果。

Answer 2

如果您通过上次分配给它的相同元素访问联合体，则不会有问题。通过访问联合的 char 大小的元素，编译器确保只返回您感兴趣的位。

编辑：人们提到了标记的联合。这是 SDL 用于其事件结构的另一种风格。

enum union_tag {
    STRUCT_A,
    STRUCT_B
};

typedef struct {
    enum union_tag tag;
    int a;
} aType;

typedef struct {
    enum union_tag tag;
    char b;
} bType;

typedef union{
    enum union_tag tag;
    aType a_type;
    bType b_type;
} ab;

要访问一个元素，你可以这样做：

int result;

switch(my_union.tag){
    case STRUCT_A:
         result = my_union.a_type.a;
         break;
    case STRUCT_B:
         result = my_union.b_type.b;
         break;
}

Answer 3

没有正确的行为。通过一个成员设置联合并从另一成员检索值会导致未定义的行为。您可以使用此技术做一些有用的事情，但它非常依赖于硬件和编译器。您将需要考虑处理器字节顺序和内存对齐要求。

当我几乎用 C 语言进行所有编程时，我非常依赖两种使用联合的（可移植）技术。

带标签的联合。当您需要动态类型变量时，这非常有用。您设置一个具有两个字段的结构：类型判别式和所有可能类型的联合。

struct variant {
  enum { INT, CHAR, FLOAT } type;
  union value {
    int i;
    char c;
    float f;
  };
};

每当更改联合值时，您都必须非常小心地正确设置类型值，并仅检索类型指定的值。

通用指针。由于您可以非常确定所有指针都具有相同的大小和表示形式，因此您可以创建指针类型的联合，并且知道您可以互换地设置和检索值，而无需考虑类型：

typedef union {
  void *v;
  int* i;
  char* c;
  float* f;
} ptr;

这对于（反）序列化二进制数据特别有用：

// serialize
ptr *p;
p.v = ...; // set output buffer
*p.c++ = 'a';
*p.i++ = 12345;
*p.f++ = 3.14159;

// deserialize
ptr *p;
p.v = ...; // set input buffer
char c = *p.c++;
int i = *p.i++;
float f = *p.f++;

仅供参考：您可以使示例更简单。这些结构是不必要的。你会得到同样的行为：

int main() {

  union {
    int a;
    char b;
  } v1;

  v1.a = 5;
  v1.b = 'a';
}

Answer 4

您描述的行为取决于平台/系统/编译器。例如，在 Intel x86 处理器上，5 可能是 gcc 编译器的 int 中的第一个字节。

联合的兴趣来自于两个主要角度

• 共享相同的内存空间，以最小化所需的内存分配（在这种情况下，第一个字节[例如]可能指示数据中的数据类型）结构/联合）。
• 分析某些数据结构，无需使用强制转换和指针。例如，在某些平台上，double 和 char[8] 之间的并集是获取 double 的每个字符/字节视图的简单方法 结构。

如果使用union没有任何好处，请不要这样做。

Answer 5

好吧，首先我们应该知道您是否使用的是 Big Endian 或 Little Endian 处理器。
窗口& Linux 使用小端格式，这意味着值 0x00000005 实际上写为 05-00-00-00，就像从右向左写一样。
因此，首先将 5 放入一个部分中，这意味着第一个字节是 05，其他字节都是 00。
将 'a' 放入 b 部分，然后用相应的 ascii 值覆盖 05，这意味着 0x61。
当你看一下结果数字应该是…97，那就是0x61的值。

联合的对齐应从头开始，但字节顺序取决于平台。
您所说的问题在 Big Endian 架构下应该正确，如 Sun Solaris 或任何 Risc 处理器。

我错了吗？

华泰