C语言数据结构深度解析：结构体与联合体的实战应用与技巧

系列文章目录

01-C语言从零到精通：常用运算符完全指南，掌握算术、逻辑与关系运算
02-C语言控制结构全解析：轻松掌握条件语句与循环语句
03-C语言函数参数传递深入解析：传值与传地址的区别与应用实例
04-C语言数组与字符串操作全解析：从基础到进阶，深入掌握数组和字符串处理技巧
05-C语言指针与内存管理：指针使用、内存泄漏与调试技巧
06-C语言数据结构深度解析：结构体与联合体的实战应用与技巧

---

---

前言

在 C 语言中，数据结构的设计是程序开发中的一个关键环节。我们常常需要通过不同的方式来组织数据，以便高效地管理和操作。结构体和联合体作为两种重要的用户自定义数据类型，提供了强大的功能，让我们能够灵活地处理多种数据类型。结构体让我们能够将不同类型的数据组织成一个整体，而联合体则通过共享内存来节省空间，并提供了另一种强大的数据存储方式。

本文将详细介绍结构体和联合体的定义、使用方法以及它们的不同应用场景。通过本篇文章，将掌握如何在 C 语言中高效使用这些数据结构，以解决实际开发中的问题。无论你是 C 语言新手还是有经验的开发者，这篇文章都将为你提供有价值的知识，帮助你更好地组织和管理程序中的数据。

---

一、结构体的定义与使用

在 C 语言中，结构体是一种非常常见的用户自定义数据类型。结构体的作用是将不同类型的数据组合成一个整体，可以帮助我们以更清晰、有效的方式处理数据。结构体广泛应用于程序中，尤其是在处理与实体相关的信息时。接下来，我们将详细探讨结构体的定义、使用方法以及常见的操作。

1.1 结构体的基本概念

结构体是通过 struct 关键字定义的一个自定义类型，它可以包含多种不同类型的数据。每个数据项称为结构体的“成员”或“字段”。不同于数组，数组中的元素必须是相同类型的数据，而结构体允许我们将多种不同类型的数据组合在一起。

1.1.1 结构体的定义

定义一个结构体的语法格式如下：

struct 结构体名称 {
    数据类型 成员1;
    数据类型 成员2;
    // 更多成员
};

例如，我们定义一个 Student 结构体，用来表示学生的姓名、年龄和成绩。代码如下：

struct Student {
    char name[50];   // 学生姓名
    int age;         // 学生年龄
    float score;     // 学生成绩
};

上述代码中，我们定义了一个名为 Student 的结构体，它包含了三个成员：name（字符数组）、age（整数）和 score（浮点数）。

1.1.2 定义结构体变量

一旦我们定义了结构体类型，就可以用它来声明变量。结构体变量的定义语法类似于其他数据类型，只需要指定结构体类型名即可。下面是定义一个结构体变量的例子：

struct Student student1;

这行代码定义了一个名为 student1 的 Student 类型变量，它可以用来存储一个学生的信息。接下来，我们可以通过点运算符（.）来访问结构体成员。

1.1.3 结构体初始化

在声明结构体变量时，我们也可以为它们的成员进行初始化。结构体变量的初始化方式有两种常见方式：

1.1.3.1 使用大括号初始化

可以通过大括号初始化结构体成员：

struct Student student1 = {"John", 20, 85.5};

这行代码将 student1 的 name 设置为 “John”，age 设置为 20，score 设置为 85.5。

1.1.3.2 单独初始化成员

结构体变量的每个成员也可以单独初始化。比如：

struct Student student1;
strcpy(student1.name, "John");
student1.age = 20;
student1.score = 85.5;

这种方式给每个成员赋值更加灵活，适用于动态赋值的场景。

1.2 结构体成员的访问

我们可以通过结构体变量和成员名来访问结构体的各个成员。访问结构体成员时，使用点运算符（.）。例如：

printf("Name: %s\n", student1.name);    // 输出姓名
printf("Age: %d\n", student1.age);      // 输出年龄
printf("Score: %.2f\n", student1.score); // 输出成绩

通过点运算符，结构体变量 student1 的成员可以直接访问和输出。

1.3 结构体作为函数参数

结构体在 C 语言中不仅可以作为局部变量使用，还可以作为函数的参数。函数传递结构体参数时，有两种常见的传递方式：按值传递和按引用传递。

1.3.1 按值传递

按值传递是指将结构体的副本传递给函数。此时函数内对结构体的修改不会影响原来的结构体。

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

调用该函数时，原结构体的值不会被修改。

printStudent(student1);

1.3.2 按引用传递

按引用传递是通过指针将结构体传递给函数。在这种方式下，函数内对结构体的修改会直接影响原始结构体。

void modifyScore(struct Student *s) {
    s->score = 95.0;  // 使用箭头运算符访问指针中的结构体成员
}

调用时需要传递结构体的地址：

modifyScore(&student1);

此时，student1 的 score 成员会被修改为 95.0。

1.3.3 按引用传递与按值传递的选择

• 按值传递：传递结构体的副本，避免修改原始数据，适用于不需要修改结构体的场合。
• 按引用传递：传递结构体的指针，可以直接修改原始数据，适用于需要修改结构体的场合。

1.4 结构体内存布局与对齐

结构体的内存布局可能会根据系统架构进行对齐优化。由于不同类型的数据需要不同的存储空间，编译器会根据数据类型的对齐要求来排列结构体成员，以提高内存访问的效率。

1.4.1 结构体对齐规则

在某些平台上，为了提高效率，结构体成员之间会有填充字节。这些填充字节的存在可能会导致结构体的总大小大于所有成员的大小之和。我们可以使用 sizeof() 函数来查看结构体的实际大小。

printf("Size of student1: %zu bytes\n", sizeof(student1));

通过 sizeof() 函数，我们可以了解结构体在内存中的实际大小，包括填充字节。

1.4.2 对齐优化

在定义结构体时，如果需要控制内存布局，可以使用 #pragma pack() 指令来控制内存对齐。不过，通常情况下，使用默认的内存对齐就足够了。

---

二、结构体数组与嵌套结构体

在 C 语言中，结构体不仅可以单独使用，还可以与数组、其他结构体等数据结构结合，形成更加复杂的数据组织方式。结构体数组和嵌套结构体是两种常见的用法，能够帮助我们处理更复杂的数据结构。本节将详细讲解结构体数组和嵌套结构体的定义、使用方法和常见应用场景。

2.1 结构体数组

结构体数组是指数组中的每个元素都是一个结构体类型。结构体数组使得我们可以轻松地存储多个相同类型的结构体实例，适用于管理多个相似对象的数据，例如多个学生、多个员工等。

2.1.1 定义结构体数组

结构体数组的定义方式与普通数组类似，区别在于数组元素是结构体类型，而不是基本数据类型。下面是一个定义结构体数组的示例：

struct Student {
    char name[50];  // 学生姓名
    int age;        // 学生年龄
    float score;    // 学生成绩
};

// 定义一个包含5个学生的结构体数组
struct Student students[5];

上述代码定义了一个名为 students 的结构体数组，它包含 5 个 Student 结构体元素。每个元素代表一个学生的信息。

2.1.2 访问结构体数组中的元素

要访问结构体数组中的元素，可以使用数组下标和点运算符。例如：

strcpy(students[0].name, "Alice");  // 设置第一个学生的姓名
students[0].age = 18;               // 设置第一个学生的年龄
students[0].score = 95.5;           // 设置第一个学生的成绩

printf("Name: %s\n", students[0].name);
printf("Age: %d\n", students[0].age);
printf("Score: %.2f\n", students[0].score);

通过数组下标 [0]，我们访问到 students 数组中的第一个学生 student[0]，然后使用点运算符访问并修改它的成员。

2.1.3 结构体数组的初始化

与普通数组一样，结构体数组也可以在定义时进行初始化。我们可以像这样初始化整个数组：

struct Student students[2] = {
    {"Alice", 18, 95.5},
    {"Bob", 20, 88.0}
};

这段代码创建了一个 students 数组，包含 2 个学生，并对每个学生的成员进行初始化。

另外，结构体数组也可以逐个初始化：

struct Student students[2];

strcpy(students[0].name, "Alice");
students[0].age = 18;
students[0].score = 95.5;

strcpy(students[1].name, "Bob");
students[1].age = 20;
students[1].score = 88.0;

2.1.4 结构体数组的应用

结构体数组的一个常见应用是处理一组相似对象的数据。例如，在管理学生信息时，我们可能需要存储多个学生的姓名、年龄和成绩。通过结构体数组，我们可以方便地将这些信息存储到数组中，进行批量操作。

例如，计算全体学生的平均成绩：

float total_score = 0;
for (int i = 0; i < 5; i++) {
    total_score += students[i].score;
}
float average_score = total_score / 5;
printf("Average Score: %.2f\n", average_score);

2.2 嵌套结构体

嵌套结构体是指在结构体中定义另一个结构体作为成员。通过嵌套结构体，我们可以表示更复杂的数据关系，尤其是在处理层次化、组合型数据时，嵌套结构体提供了强大的数据组织能力。

2.2.1 嵌套结构体的定义

嵌套结构体的定义与普通结构体类似，唯一的不同是结构体的成员可以是另一个结构体类型。下面是一个嵌套结构体的例子：

struct Address {
    char street[100];
    char city[50];
    char zipCode[20];
};

struct Student {
    char name[50];
    int age;
    struct Address address;  // 嵌套结构体
};

在这个例子中，Student 结构体中有一个成员 address，它是 Address 结构体类型的一个实例。Address 结构体用于表示学生的住址信息，Student 结构体则包含学生的姓名、年龄和住址。

2.2.2 访问嵌套结构体成员

访问嵌套结构体的成员时，需要使用多个点运算符。首先访问外部结构体的成员，然后再访问嵌套结构体的成员。例如：

struct Student student1;
strcpy(student1.name, "John");
student1.age = 20;
strcpy(student1.address.street, "123 Main St");
strcpy(student1.address.city, "New York");
strcpy(student1.address.zipCode, "10001");

printf("Student Name: %s\n", student1.name);
printf("Student Age: %d\n", student1.age);
printf("Address: %s, %s, %s\n", student1.address.street, student1.address.city, student1.address.zipCode);

在上述代码中，我们首先通过 student1.address 访问嵌套的 Address 结构体，再通过 student1.address.street 等访问具体的成员。

2.2.3 嵌套结构体的初始化

嵌套结构体的初始化方式与普通结构体类似，我们可以在定义时同时初始化外部结构体和嵌套的结构体成员：

struct Student student1 = {
    "John",          // 姓名
    20,              // 年龄
    {"123 Main St", "New York", "10001"}  // 地址
};

在这个例子中，我们在初始化 Student 结构体的同时，也初始化了它的嵌套成员 Address。

2.2.4 嵌套结构体的应用

嵌套结构体可以帮助我们更加清晰地组织数据，尤其是当数据有层次关系时。例如，在表示一个学生的地址时，我们可以将地址分为街道、城市和邮政编码等不同部分，每个部分可以用嵌套结构体表示。这种组织方式比将所有信息放在一个结构体中要更清晰、更容易管理。

另一个例子是管理公司员工信息时，可以使用嵌套结构体来表示员工的个人信息和工作信息：

struct Job {
    char title[50];
    float salary;
};

struct Employee {
    char name[50];
    struct Job job;  // 嵌套结构体
};

通过这种方式，我们可以在 Employee 结构体中同时存储员工的姓名和工作信息。

---

三、联合体的定义与应用

联合体（Union）是 C 语言中的一种特殊数据类型，它允许在同一内存位置存储不同类型的数据。与结构体不同，结构体的每个成员都拥有独立的内存空间，而联合体的所有成员共享同一块内存区域。因此，联合体在节省内存空间的同时，也限制了在同一时刻只能使用一个成员的值。本节将详细介绍联合体的定义、使用方法以及应用场景。

3.1 联合体的基本概念

联合体是一种特殊的数据结构，它能够将多个不同类型的数据保存在同一块内存中，但每次只能存储其中的一个成员。联合体的成员共享同一块内存空间，且该空间的大小由其中最大成员的大小决定。

3.1.1 联合体的定义

联合体的定义语法与结构体类似，使用 union 关键字而不是 struct 关键字。每个成员的类型可以不同，但所有成员共享同一块内存空间。联合体的定义如下：

union 联合体名称 {
    数据类型 成员1;
    数据类型 成员2;
    // 其他成员
};

例如，我们可以定义一个联合体 Data，它可以存储一个整数、一个浮点数或一个字符串：

union Data {
    int i;
    float f;
    char str[20];
};

在上述代码中，Data 联合体有三个成员：i（整数）、f（浮点数）和 str（字符数组）。它们共享同一块内存空间，这意味着在任何时刻，联合体 Data 只能存储其中一个成员的数据。

3.1.2 联合体的大小

联合体的大小是它最大成员的大小。例如，在上面的例子中，str 是一个字符数组，它有 20 个字符，因此 Data 联合体的大小为 20 字节，而不是所有成员大小的总和。可以通过 sizeof 运算符来查看联合体的实际大小：

printf("Size of union Data: %zu bytes\n", sizeof(union Data));

3.2 联合体的使用

联合体的使用与结构体类似，我们可以声明联合体变量并使用点运算符来访问其成员。然而，由于联合体成员共享内存，因此每次只能给一个成员赋值。

3.2.1 定义和访问联合体成员

首先，我们定义一个联合体变量并给其中一个成员赋值。例如：

union Data data1;
data1.i = 10;   // 给整数成员赋值
printf("Data1.i: %d\n", data1.i);

此时，data1.i 成员被赋值为 10，并且 data1 中的其他成员（如 f 和 str）的数据会被覆盖。

接下来，我们可以给其他成员赋值：

data1.f = 3.14;   // 给浮点数成员赋值
printf("Data1.f: %.2f\n", data1.f);

此时，data1.f 成员被赋值为 3.14，而 data1.i 的值被覆盖。

最后，我们可以赋值给 str 成员：

strcpy(data1.str, "Hello, Union!");   // 给字符数组成员赋值
printf("Data1.str: %s\n", data1.str);

此时，data1.str 被赋值为 “Hello, Union!”，而其他成员的数据被覆盖。需要注意的是，只有最后赋值的成员有效。

3.2.2 联合体的赋值与覆盖

由于联合体的成员共享同一块内存，因此每次对联合体的成员赋值时，实际上是覆盖掉之前赋值的成员数据。我们可以通过赋值和访问不同的成员来使用联合体，但只能在同一时刻存储一个成员的值。

union Data data2;
data2.i = 5;           // 赋值整数
printf("Data2.i: %d\n", data2.i);

data2.f = 7.5;         // 赋值浮点数，覆盖整数
printf("Data2.f: %.2f\n", data2.f);

strcpy(data2.str, "Test");  // 赋值字符串，覆盖浮点数
printf("Data2.str: %s\n", data2.str);

可以看到，每次赋值时都会覆盖前一个成员的值。联合体的特点就是它的所有成员共享内存，赋值给一个成员会影响到其他成员。

3.2.3 联合体的应用场景

联合体在一些特定的场景中非常有用，特别是在内存有限且只需要存储某一类数据的场合。由于联合体成员共享内存空间，使用联合体可以有效节省内存，尤其是在不需要同时存储所有成员数据时。

3.2.3.1 节省内存空间

假设我们需要处理多个数据类型，但每个实例只会使用其中的一种数据类型。在这种情况下，使用结构体会浪费大量内存，因为每个成员都需要独立的内存空间。而使用联合体可以节省内存，因为所有成员共享同一块内存空间。

例如，假设我们需要存储一个值，可能是整数、浮点数或字符串中的任意一种。使用联合体时，只有当前存储的数据类型所需的内存空间被分配，而不需要为每种数据类型分别分配内存。

union Data {
    int i;
    float f;
    char str[20];
};

union Data data;
data.i = 42;        // 存储整数
// data.f 和 data.str 的值不确定，因为它们被覆盖

3.2.3.2 实现多态行为

联合体在某些编程场景中也可以实现类似于多态的行为。通过联合体，我们可以在同一变量中存储不同类型的数据，这对于一些特定的数据结构非常有用，例如处理不同类型的数据包或消息。

例如，在网络编程中，可能有多种不同类型的数据包格式，我们可以使用联合体来存储不同类型的数据包：

union DataPacket {
    int intData;
    float floatData;
    char strData[50];
};

在这种情况下，数据包的类型可以根据需要进行调整，但它们共享同一块内存，节省了存储空间。

---

四、总结

通过本文的学习，我们深入了解了 C 语言中的结构体和联合体，掌握了它们的基本概念、定义方法和应用技巧。总结起来，本文内容包括：

• 结构体的定义与使用：结构体是将不同类型的数据组合在一起，形成一个新的数据类型。通过结构体数组和嵌套结构体，我们可以更加方便地管理复杂数据。
• 结构体数组与嵌套结构体：结构体数组允许我们存储多个相同类型的结构体，适用于处理一组相似的数据；嵌套结构体则使我们可以组织层次化的数据，使数据的表示更加清晰。
• 联合体的定义与应用：联合体允许在同一内存位置存储不同类型的数据。通过了解联合体的内存共享特性，我们可以在内存有限的情况下，节省空间并提高程序的效率。

这两种数据结构各有特点，在实际开发中可以根据不同的需求选择合适的方式来组织和管理数据。掌握它们的使用，能够帮助我们写出更加高效、清晰的代码，提高程序的可维护性和扩展性。