C 联合对变量有什么帮助？

我已经对此进行了研究，并探索了union的用例。每个消息来源都说它在结构上是内存有效的，我理解这一点

但当你说：

Union的变量共享相同的内存，当您更改一个变量的值时，另一个变量的值就会更改，并且一次只能访问一个变量

那么，为什么需要声明union及其子变量，为什么我不能通过将最大内存分配为union最大变量来使用1个简单变量呢

考虑这个例子：

union {
   int length;
   int breadth;
   char status;
} dimension;

Versus

int dimension;  # Now this can store the highest value similar to length and breadth.

---

我认为当您不清楚变量的类型时，我们使用union

我在将汇编语言转换为c代码时使用了union。有时一个变量用作int变量，有时用作指针。在这个时候，我使用了union

union {
  int data;
  void* handle;
}

---

我希望这有助于您的理解。

我认为，当您不清楚变量的类型时，我们使用union

我在将汇编语言转换为c代码时使用了union。有时一个变量用作int变量，有时用作指针。在这个时候，我使用了union

union {
  int data;
  void* handle;
}

我希望这有助于你的理解

那么，为什么需要声明union及其子变量，为什么我不能通过将最大内存分配为union最大变量来使用1个简单变量呢

你可以这么做，但一个联盟会让这更容易

您的特定示例没有多大意义，主要是因为您有两个相同类型的实例，但也因为它们都是整数。让我们以您链接的帖子为例：

union {
  int i;
  float f;
} u;

这意味着您可以在希望将内存视为

int

或

u.f

时使用

u.i

，如果希望将其视为浮点

float

假设你想在没有并集的情况下解决这个问题，只需要声明一个变量“足够大”。你选择哪种类型

int

至少为16位，

float

至少为32位。那么我们选择一个

浮点

？不，因为可能在目标系统上，

int

是64位，而

float

32位。那么让我们做的太多了，选择现存的最大类型？好吧，你可以，但是那样做会破坏保存内存的目的

如果声明为变量，我们如何将它们作为不同的类型访问？考虑这个代码：

float x;
int y = *(int*) x;

应该很好，对吧？不，除了大小可能不同的问题之外，您还将遇到表示方面的问题。有许多不同的方式来表示整数和浮点数。你也可能会遇到持久性的问题

您可以模拟联合的行为而不实际使用它们，但这需要大量额外的工作。由此产生的代码很可能包含很多bug，而且速度可能慢得多，可移植性也差得多

一个用例是实现多态性。这是一个非常简单的例子，而且tbh，它看起来并没有使事情变得更容易，但这通常是例子的情况。假设我们有：

void print_float(float f)
{
    printf("Value: %f\n", f);
}

void print_int(int i)
{
    printf("Value: %d\n", i);
}

可由以下内容取代：

struct multitype {
    union {
        int i;
        float f;
    } data;
    enum { INT, FLOAT } type;
};

void print(struct multitype x)
{
    switch(x.type) {
    case INT:     printf("Value: %d\n", x.data.i); break;
    case FLOAT:   printf("Value: %f\n", x.data.f); break;
    }
}

那么，为什么需要声明union及其子变量，为什么我不能通过将最大内存分配为union最大变量来使用1个简单变量呢

你可以这么做，但一个联盟会让这更容易

您的特定示例没有多大意义，主要是因为您有两个相同类型的实例，但也因为它们都是整数。让我们以您链接的帖子为例：

union {
  int i;
  float f;
} u;

这意味着您可以在希望将内存视为

int

或

u.f

时使用

u.i

，如果希望将其视为浮点

float

假设你想在没有并集的情况下解决这个问题，只需要声明一个变量“足够大”。你选择哪种类型

int

至少为16位，

float

至少为32位。那么我们选择一个

浮点

？不，因为可能在目标系统上，

int

是64位，而

float

32位。那么让我们做的太多了，选择现存的最大类型？好吧，你可以，但是那样做会破坏保存内存的目的

如果声明为变量，我们如何将它们作为不同的类型访问？考虑这个代码：

float x;
int y = *(int*) x;

应该很好，对吧？不，除了大小可能不同的问题之外，您还将遇到表示方面的问题。有许多不同的方式来表示整数和浮点数。你也可能会遇到持久性的问题

您可以模拟联合的行为而不实际使用它们，但这需要大量额外的工作。由此产生的代码很可能包含很多bug，而且速度可能慢得多，可移植性也差得多

一个用例是实现多态性。这是一个非常简单的例子，而且tbh，它看起来并没有使事情变得更容易，但这通常是例子的情况。假设我们有：

void print_float(float f)
{
    printf("Value: %f\n", f);
}

void print_int(int i)
{
    printf("Value: %d\n", i);
}

可由以下内容取代：

struct multitype {
    union {
        int i;
        float f;
    } data;
    enum { INT, FLOAT } type;
};

void print(struct multitype x)
{
    switch(x.type) {
    case INT:     printf("Value: %d\n", x.data.i); break;
    case FLOAT:   printf("Value: %f\n", x.data.f); break;
    }
}

---

在这个特殊的例子中，你是对的。当类型不是全部整数时，它变得更具挑战性；考虑<代码>联合Fo{{long int i；double d；char *s；}；<代码>。你不能安全地将它们中的任何一个存储在其他任何一个中。举个愚蠢的例子，想象一个数据结构需要存储有关当前或以前员工的信息。如果他们是当前员工，我们需要存储他们的工资。如果是前者，我们需要将它们离开的原因存储为字符串。您可以有一个数据结构

struct employee{char*name；bool current；union more\u info{int salary；char*deparation\u reason；}这是否回答了您的问题@Deepak我给你举了一个多态的例子，通常的做法是有一个结构的联合体。然后你可以做这个人做过的事情：在这个特定的例子中，你是对的。当类型不是全部整数时，它变得更具挑战性；考虑<代码>联合Fo{{long int I；