C 语言结构体与共用体的深度解析及实战应用

在 C 语言中，结构体（struct） 和 共用体（union） 是两种重要的复合数据类型，用于组织和管理复杂数据。结构体允许将不同类型的数据组合成一个整体，而共用体则强调内存共享，常用于节省空间或实现多态数据表示。本文将从基础概念入手，进行深度解析，包括内存机制、语法细节和优化技巧，然后通过实战示例展示应用。如果你熟悉基本 C 语法（如变量、指针），这将帮助你更好地理解。示例基于标准 C（C99+），使用 GCC 编译器测试。

1. 基础概念

1.1 结构体（struct）

• 定义：结构体是一种用户自定义的数据类型，将多个不同类型的变量组合成一个单元。每个成员有独立的内存空间。
• 用途：模拟现实世界的对象，如学生记录（姓名、年龄、成绩）。
• 特点：
• 成员顺序固定，按声明顺序存储。
• 支持嵌套、数组、指针等。
• 内存分配：总大小是成员大小之和（考虑对齐）。

1.2 共用体（union）

• 定义：共用体也是一种复合类型，但所有成员共享同一块内存空间。大小等于最大成员的大小。
• 用途：存储变体数据（如一个变量可能为 int 或 float），或实现位字段的内存复用。
• 特点：
• 只能同时使用一个成员（覆盖式写入）。
• 常用于内存优化或类型转换。
• 内存分配：所有成员从同一地址开始。

1.3 区别对比

使用表格总结二者异同，便于理解：

方面	结构体 (struct)	共用体 (union)
内存布局	成员独立内存，总大小为成员之和（+对齐）	成员共享内存，总大小为最大成员
访问方式	通过 . 或 -> 访问每个成员	通过 . 或 -> 访问，但只能用一个
典型用途	数据聚合（如对象模型）	数据变体、内存节省、类型伪装
大小计算	sizeof(struct) = sum(sizeof(成员)) + padding	sizeof(union) = max(sizeof(成员))
初始化	可以整体初始化 {val1, val2}	只初始化一个成员
嵌套	支持嵌套结构体/共用体	支持嵌套，但共享内存复杂

注意：二者都可作为类型定义，使用 typedef 简化（如 typedef struct Point Point;）。

2. 深度解析

2.1 结构体的语法与内存机制

• 声明与定义：

  struct Point {  // 声明
      int x;      // 成员（字段）
      int y;
      double z;   // 不同类型
  };

  struct Point p1;  // 定义变量

• 初始化与访问：

  struct Point p2 = {1, 2, 3.0};  // 顺序初始化
  p2.x = 10;                      // 访问

• 内存布局与对齐：
  C 编译器为优化访问速度，进行字节对齐（padding）。例如，在 64-bit 系统：
• int (4 字节) + char (1 字节) 可能补 3 字节 padding，使总大小 8 字节。
• 计算：sizeof(struct Point) 可能为 16 字节（int 4+4=8，双精度 8）。
• pragma pack：控制对齐，如 #pragma pack(1) 禁用 padding（节省空间，但慢）。
• 嵌套与数组：

  struct Rectangle {
      struct Point topLeft;
      struct Point bottomRight;
  };

  struct Point points[10];  // 结构体数组

• 指针与动态分配：

  struct Point* ptr = &p1;  // 指针
  ptr->y = 20;              // 箭头访问

  struct Point* dyn = malloc(sizeof(struct Point));  // 动态
  free(dyn);

• 位字段（bit-field）：节省位级内存。

  struct Flags {
      unsigned int flag1 : 1;  // 占 1 位
      unsigned int flag2 : 3;  // 占 3 位
  };  // 总大小可能 4 字节

2.2 共用体的语法与内存机制

• 声明与定义：

  union Variant {  // 声明
      int i;
      float f;
      char c;
  };

  union Variant v;  // 定义

• 初始化与访问：

  union Variant u = {.f = 3.14};  // C99 指定初始化
  printf("%f\n", u.f);            // 访问
  u.i = 42;                       // 覆盖 f

• 内存布局：
• 所有成员地址相同：&u.i == &u.f == &u.c。
• 大小：sizeof(union Variant) = 4（int/float 4 字节，char 1 但取最大）。
• 字节序：依赖系统（大端/小端），访问时需小心类型转换。
• 匿名共用体（C11+）：

  struct Data {
      int type;
      union {  // 匿名
          int i;
          float f;
      };
  };
  struct Data d;
  d.f = 1.0;  // 直接访问

• 与结构体的结合：常用于变体记录（tagged union）。

  struct TaggedVariant {
      enum { INT, FLOAT } tag;  // 标签标识类型
      union {
          int i;
          float f;
      } data;
  };

2.3 高级主题：优化与陷阱

• 内存效率：结构体适合大数据聚合，共用体适合可选数据（如 JSON 解析的变体值）。
• 对齐与移植性：不同编译器/平台对齐不同，使用 offsetof 检查偏移。
• 常见陷阱：
• 共用体：读取未初始化的成员导致未定义行为（UB）。
• 结构体：忘记初始化导致垃圾值。
• 联合使用：避免在共用体中嵌套指针（内存覆盖风险）。
• 性能：结构体访问快（缓存友好），共用体需标签检查稍慢。

3. 实战应用

3.1 结构体实战：学生信息管理系统

假设管理学生数据，包括姓名、年龄、成绩。使用结构体数组和函数操作。

#include <stdio.h>
#include <string.h>

typedef struct Student {
    char name[50];
    int age;
    float score;
} Student;

void printStudent(const Student* s) {
    printf("Name: %s, Age: %d, Score: %.2f\n", s->name, s->age, s->score);
}

int main() {
    Student students[3] = {
        {"Alice", 20, 85.5},
        {"Bob", 22, 90.0},
        {"Charlie", 21, 78.0}
    };

    // 修改
    students[0].age = 21;

    // 遍历
    for (int i = 0; i < 3; i++) {
        printStudent(&students[i]);
    }

    return 0;
}

输出：

Name: Alice, Age: 21, Score: 85.50
Name: Bob, Age: 22, Score: 90.00
Name: Charlie, Age: 21, Score: 78.00

应用场景：数据库记录、图形坐标系统。

3.2 共用体实战：变体数据处理器

处理不同类型的事件数据，使用 tagged union。

#include <stdio.h>

typedef enum { EVENT_INT, EVENT_FLOAT, EVENT_CHAR } EventType;

typedef struct Event {
    EventType type;
    union {
        int iVal;
        float fVal;
        char cVal;
    } value;
} Event;

void processEvent(const Event* e) {
    switch (e->type) {
        case EVENT_INT: printf("Int: %d\n", e->value.iVal); break;
        case EVENT_FLOAT: printf("Float: %.2f\n", e->value.fVal); break;
        case EVENT_CHAR: printf("Char: %c\n", e->value.cVal); break;
    }
}

int main() {
    Event e1 = {EVENT_INT, {.iVal = 100}};
    Event e2 = {EVENT_FLOAT, {.fVal = 3.14}};
    Event e3 = {EVENT_CHAR, {.cVal = 'A'}};

    processEvent(&e1);
    processEvent(&e2);
    processEvent(&e3);

    // 内存大小演示
    printf("Size of Event: %zu bytes\n", sizeof(Event));  // ~8-16 字节

    return 0;
}

输出：

Int: 100
Float: 3.14
Char: A
Size of Event: 8 bytes  // 示例值

应用场景：网络协议解析（变长字段）、嵌入式系统（内存紧缺）、JSON/XML 解码。

3.3 混合实战：链表节点（结构体嵌套共用体）

实现简单链表，每个节点数据为变体。

#include <stdio.h>
#include <stdlib.h>

typedef struct Node {
    union {
        int i;
        char* str;
    } data;
    int isInt;  // 标签：1 为 int，0 为 str
    struct Node* next;
} Node;

Node* createIntNode(int val) {
    Node* n = malloc(sizeof(Node));
    n->data.i = val;
    n->isInt = 1;
    n->next = NULL;
    return n;
}

Node* createStrNode(const char* s) {
    Node* n = malloc(sizeof(Node));
    n->data.str = strdup(s);  // 复制字符串
    n->isInt = 0;
    n->next = NULL;
    return n;
}

void printNode(const Node* n) {
    if (n->isInt) {
        printf("Int: %d\n", n->data.i);
    } else {
        printf("String: %s\n", n->data.str);
    }
}

void freeNode(Node* n) {
    if (!n->isInt) free(n->data.str);
    free(n);
}

int main() {
    Node* head = createIntNode(42);
    head->next = createStrNode("Hello");

    Node* current = head;
    while (current) {
        printNode(current);
        Node* temp = current;
        current = current->next;
        freeNode(temp);
    }

    return 0;
}

输出：

Int: 42
String: Hello

应用场景：异构数据链表、配置解析器。

4. 注意事项与最佳实践

• 兼容性：C89 支持基本 struct/union，C99+ 添加指定初始化。
• 调试：用 gdb 检查内存：print /x &p.x 查看地址。
• 安全：避免缓冲区溢出（如 strcpy），用 strncpy。
• 优化：结构体成员按大小降序声明减少 padding。
• 扩展：在 C++ 中，struct 支持类特性，但 C 保持纯数据。
• 常见错误：共用体类型不匹配导致 UB；结构体复制时忘记深拷贝指针。

通过这些解析和示例，你可以灵活应用 struct 和 union 于实际项目。如果需要更多代码（如文件操作整合）或特定编译环境测试，提供细节我来帮你！保持编码实践，C 的复合类型会让你事半功倍。