第 8 章结构体与共用体

对应教材目录

8.1 结构体概述
8.1.1 结构体类型的定义
8.1.2 结构体变量的定义
8.1.3 结构体变量的引用
8.1.4 结构体变量的赋值和初始化
8.2 结构体数组
8.3 指向结构体的指针
8.3.1 指向结构体的指针变量的定义
8.3.2 利用结构体指针变量引用成员
8.3.3 用结构体类型作函数参数
8.4 用结构体处理链表
8.4.1 链表概述
8.4.2 链表的建立与输出
8.4.3 链表的插入
8.4.4 链表的删除
8.4.5 链表的综合操作
8.5 共用体
8.5.1 共用体类型及变量的定义
8.5.2 共用体变量的引用
8.6 枚举类型
8.7 用 typedef 定义类型别名

本章目标

学完这一章，你应该能做到：

知道结构体的作用是“把多个相关数据打包在一起”。
会定义结构体类型、结构体变量，并访问结构体成员。
会给结构体变量赋值、初始化，也能使用结构体数组。
会定义结构体指针，并用 -> 访问成员。
能把结构体作为函数参数传入，知道“传值”和“传地址”的区别。
初步理解链表结点、结点连接、插入和删除的基本思想。
知道共用体、枚举类型和 typedef 的基本用法。

1. 为什么要学结构体与共用体

前面你学过的变量，大多一次只保存一个值。

例如：

1
int num;
2
char name[20];
3
float score;

如果这三个值本来就属于同一个学生，那么把它们分散写开，管理起来就很不方便。

这时就需要结构体。

你可以先把结构体理解成：

把多个相关变量打包成一个整体。

比如一个学生，通常会有：

学号
姓名
成绩

这三个信息放在一起，才更像一个完整对象。

而共用体、枚举类型、typedef，则是在“组织数据”这条路上继续往前走。

2. 结构体概述

2.1 结构体类型的定义

定义结构体类型的基本写法：

1
struct Student
2
{
3
    int num;
4
    char name[20];
5
    float score;
6
};

这里要注意三件事：

struct Student 是结构体类型名。
花括号里面写的是成员。
最后那个分号不能漏。

这段代码只是“定义了一种结构”，还没有真正创建变量。

你可以把它理解成：

这是一个模板
说明“学生”这种数据由哪些部分组成

2.2 结构体变量的定义

有了结构体类型后，才能定义结构体变量：

1
struct Student stu1;

也可以一边定义类型，一边定义变量：

1
struct Student
2
{
3
    int num;
4
    char name[20];
5
    float score;
6
} stu1, stu2;

但初学阶段更建议你分开写，因为更清楚。

2.3 结构体变量的引用

访问结构体成员时，用点运算符 .：

1
stu1.num = 1001;
2
stu1.score = 95.5;

如果成员是字符数组，也可以这样初始化：

1
strcpy(stu1.name, "Alice");

完整例子：

1
#include <stdio.h>
2
#include <string.h>
3

4
struct Student
5
{
6
    int num;
7
    char name[20];
8
    float score;
9
};
10

11
int main(void)
12
{
13
    struct Student stu1;
14

15
    stu1.num = 1001;
16
    strcpy(stu1.name, "Alice");
17
    stu1.score = 95.5f;
18

19
    printf("%d %s %.1f\n", stu1.num, stu1.name, stu1.score);
20
    return 0;
21
}

2.4 结构体变量的赋值和初始化

结构体变量可以直接初始化：

1
struct Student stu = {1001, "Alice", 95.5f};

也可以一个成员一个成员赋值。

另外，两个同类型结构体变量之间，通常可以直接整体赋值：

1
struct Student s1 = {1001, "Alice", 95.5f};
2
struct Student s2;
3

4
s2 = s1;

这样 s2 就会得到 s1 的全部成员值。

完整例子：

1
#include <stdio.h>
2

3
struct Date
4
{
5
    int year;
6
    int month;
7
    int day;
8
};
9

10
int main(void)
11
{
12
    struct Date d1 = {2026, 4, 20};
13
    struct Date d2;
14

15
    d2 = d1;
16

17
    printf("%d-%d-%d\n", d2.year, d2.month, d2.day);
18
    return 0;
19
}

3. 结构体数组

如果要保存很多同类对象，就会用到结构体数组。

例如保存 3 个学生的信息：

1
struct Student stu[3];

结构体数组和普通数组的思想一样：

每个元素都是同一种结构体
可以用下标访问每个元素

示例：

1
#include <stdio.h>
2

3
struct Student
4
{
5
    int num;
6
    char name[20];
7
    float score;
8
};
9

10
int main(void)
11
{
12
    struct Student stu[3] = {
13
        {1001, "Alice", 95.5f},
14
        {1002, "Bob", 88.0f},
15
        {1003, "Cindy", 91.5f}
16
    };
17
    int i;
18

19
    for (i = 0; i < 3; i++) {
20
        printf("%d %s %.1f\n", stu[i].num, stu[i].name, stu[i].score);
21
    }
22

23
    return 0;
24
}

再看一个更常见的题：求结构体数组中的最高分。

1
#include <stdio.h>
2

3
struct Student
4
{
5
    int num;
6
    char name[20];
7
    float score;
8
};
9

10
int main(void)
11
{
12
    struct Student stu[4] = {
13
        {1001, "Alice", 95.5f},
14
        {1002, "Bob", 88.0f},
15
        {1003, "Cindy", 91.5f},
16
        {1004, "David", 97.0f}
17
    };
18
    int i, k = 0;
19

20
    for (i = 1; i < 4; i++)
21
    {
22
        if (stu[i].score > stu[k].score) {
23
            k = i;
24
        }
25
    }
26

27
    printf("%d %s %.1f\n", stu[k].num, stu[k].name, stu[k].score);
28
    return 0;
29
}

4. 指向结构体的指针

4.1 指向结构体的指针变量的定义

结构体变量当然也有地址，所以也可以定义结构体指针。

例如：

1
struct Student stu;
2
struct Student *p = &stu;

这里：

stu 是结构体变量
p 是指向结构体变量 stu 的指针

4.2 利用结构体指针变量引用成员

通过结构体指针访问成员，有两种写法：

1
(*p).num

和

1
p->num

第二种更常用，也更清楚。

完整例子：

1
#include <stdio.h>
2
#include <string.h>
3

4
struct Student
5
{
6
    int num;
7
    char name[20];
8
    float score;
9
};
10

11
int main(void)
12
{
13
    struct Student stu;
14
    struct Student *p = &stu;
15

16
    p->num = 1001;
17
    strcpy(p->name, "Alice");
18
    p->score = 95.5f;
19

20
    printf("%d %s %.1f\n", p->num, p->name, p->score);
21
    printf("%d %s %.1f\n", (*p).num, (*p).name, (*p).score);
22
    return 0;
23
}

这两个 printf 输出的内容是一样的。

4.3 用结构体类型作函数参数

结构体可以作为函数参数传递。

先看“按值传递”的写法：

1
void print_student(struct Student stu)
2
{
3
    printf("%d %s %.1f\n", stu.num, stu.name, stu.score);
4
}

这里函数拿到的是结构体副本。

如果想在函数里真正修改外部结构体，通常要传地址：

1
void set_score(struct Student *stu, float score)
2
{
3
    stu->score = score;
4
}

完整例子：

1
#include <stdio.h>
2
#include <string.h>
3

4
struct Student
5
{
6
    int num;
7
    char name[20];
8
    float score;
9
};
10

11
void print_student(struct Student stu)
12
{
13
    printf("%d %s %.1f\n", stu.num, stu.name, stu.score);
14
}
15

16
void set_score(struct Student *stu, float score)
17
{
18
    stu->score = score;
19
}
20

21
int main(void)
22
{
23
    struct Student stu = {1001, "Alice", 80.0f};
24

25
    print_student(stu);
26
    set_score(&stu, 95.0f);
27
    print_student(stu);
28
    return 0;
29
}

5. 用结构体处理链表

这一部分是第八章最难的地方之一。

你先不用急着一口气全部吃透，先抓住链表的核心思想：

每个结点里有数据
每个结点里还有“下一个结点的地址”
这些结点就像一节一节火车车厢，被连起来

5.1 链表概述

链表结点最常见的定义方式：

1
struct Node
2
{
3
    int data;
4
    struct Node *next;
5
};

这里：

data 用来放数据
next 用来指向下一个结点

如果 next == NULL，说明已经到链表末尾。

5.2 链表的建立与输出

先看一个最简单的例子：手动建立 3 个结点。

1
#include <stdio.h>
2
#include <stdlib.h>
3

4
struct Node
5
{
6
    int data;
7
    struct Node *next;
8
};
9

10
void print_list(struct Node *head)
11
{
12
    while (head != NULL)
13
    {
14
        printf("%d ", head->data);
15
        head = head->next;
16
    }
17
    printf("\n");
18
}
19

20
int main(void)
21
{
22
    struct Node *p1 = malloc(sizeof(struct Node));
23
    struct Node *p2 = malloc(sizeof(struct Node));
24
    struct Node *p3 = malloc(sizeof(struct Node));
25

26
    p1->data = 10;
27
    p2->data = 20;
28
    p3->data = 30;
29

30
    p1->next = p2;
31
    p2->next = p3;
32
    p3->next = NULL;
33

34
    print_list(p1);
35

36
    free(p1);
37
    free(p2);
38
    free(p3);
39
    return 0;
40
}

这段代码里，malloc 可以先理解成：

向系统申请一个新的结点空间。

5.3 链表的插入

插入的核心，不是“搬动所有数据”，而是“改指针方向”。

例如：在某个结点后面插入新结点：

1
void insert_after(struct Node *pos, struct Node *new_node)
2
{
3
    new_node->next = pos->next;
4
    pos->next = new_node;
5
}

完整例子：

1
#include <stdio.h>
2
#include <stdlib.h>
3

4
struct Node
5
{
6
    int data;
7
    struct Node *next;
8
};
9

10
void print_list(struct Node *head)
11
{
12
    while (head != NULL)
13
    {
14
        printf("%d ", head->data);
15
        head = head->next;
16
    }
17
    printf("\n");
18
}
19

20
void insert_after(struct Node *pos, struct Node *new_node)
21
{
22
    new_node->next = pos->next;
23
    pos->next = new_node;
24
}
25

26
int main(void)
27
{
28
    struct Node *p1 = malloc(sizeof(struct Node));
29
    struct Node *p2 = malloc(sizeof(struct Node));
30
    struct Node *p3 = malloc(sizeof(struct Node));
31

32
    p1->data = 10;
33
    p2->data = 30;
34
    p3->data = 20;
35

36
    p1->next = p2;
37
    p2->next = NULL;
38

39
    insert_after(p1, p3);
40
    print_list(p1);
41

42
    free(p1);
43
    free(p2);
44
    free(p3);
45
    return 0;
46
}

输出为：

1
10 20 30

5.4 链表的删除

删除结点的核心也是改指针。

例如：删除值为 target 的第一个结点。

1
struct Node *delete_value(struct Node *head, int target)
2
{
3
    struct Node *pre = NULL;
4
    struct Node *cur = head;
5

6
    while (cur != NULL && cur->data != target)
7
    {
8
        pre = cur;
9
        cur = cur->next;
10
    }
11

12
    if (cur == NULL) {
13
        return head;
14
    }
15

16
    if (pre == NULL) {
17
        head = cur->next;
18
    }
19
    else {
20
        pre->next = cur->next;
21
    }
22

23
    free(cur);
24
    return head;
25
}

这段代码先找目标结点，再把前一个结点和后一个结点重新连起来。

5.5 链表的综合操作

这一节你先把思路记住就够了。

链表最常见的综合操作有：

创建链表
输出链表
查找结点
插入结点
删除结点
释放链表

下面是一个释放链表的常见写法：

1
void free_list(struct Node *head)
2
{
3
    struct Node *p;
4

5
    while (head != NULL)
6
    {
7
        p = head;
8
        head = head->next;
9
        free(p);
10
    }
11
}

如果你先把“结点”和“next 指针”这两个概念吃透，后面的链表题就会顺很多。

6. 共用体

6.1 共用体类型及变量的定义

共用体也叫联合体，关键字是 union。

基本写法：

1
union Data
2
{
3
    int i;
4
    char c;
5
    float f;
6
};

定义变量：

1
union Data x;

你可以先把共用体和结构体做个最核心的区别：

结构体：每个成员都有自己独立的存储空间
共用体：所有成员共用同一块存储空间

也就是说，共用体在同一时刻通常只能“重点使用一个成员”。

6.2 共用体变量的引用

访问共用体成员时，也用点运算符 .：

1
x.i = 10;
2
printf("%d\n", x.i);

完整例子：

1
#include <stdio.h>
2

3
union Data
4
{
5
    int i;
6
    float f;
7
    char c;
8
};
9

10
int main(void)
11
{
12
    union Data x;
13

14
    x.i = 65;
15
    printf("%d\n", x.i);
16

17
    x.c = 'A';
18
    printf("%c\n", x.c);
19

20
    return 0;
21
}

这里要记住：

后面给哪个成员赋值，就优先把它看成当前有效内容
不要把共用体想成“几个成员都能同时独立保存不同值”

7. 枚举类型

枚举类型适合表示一组有限、固定的取值。

例如一周七天：

1
enum Weekday
2
{
3
    MON,
4
    TUE,
5
    WED,
6
    THU,
7
    FRI,
8
    SAT,
9
    SUN
10
};

定义变量：

1
enum Weekday day;
2
day = WED;

默认情况下：

MON 是 0
TUE 是 1
WED 是 2

也可以自己指定：

1
enum Level
2
{
3
    LOW = 1,
4
    MID = 3,
5
    HIGH = 5
6
};

示例：

1
#include <stdio.h>
2

3
enum Weekday
4
{
5
    MON,
6
    TUE,
7
    WED,
8
    THU,
9
    FRI,
10
    SAT,
11
    SUN
12
};
13

14
int main(void)
15
{
16
    enum Weekday day = WED;
17
    printf("%d\n", day);
18
    return 0;
19
}

8. 用 `typedef` 定义类型别名

typedef 的作用是：给一个类型起一个更方便的名字。

例如：

1
typedef int Integer;

以后就可以写：

1
Integer a, b;

在结构体里，typedef 也特别常见：

1
typedef struct Student
2
{
3
    int num;
4
    char name[20];
5
    float score;
6
} Student;

这样以后定义变量时就可以直接写：

1
Student stu;

不用每次都写 struct Student。

完整例子：

1
#include <stdio.h>
2

3
typedef struct Student
4
{
5
    int num;
6
    char name[20];
7
    float score;
8
} Student;
9

10
int main(void)
11
{
12
    Student stu = {1001, "Alice", 95.5f};
13
    printf("%d %s %.1f\n", stu.num, stu.name, stu.score);
14
    return 0;
15
}

9. 本章常见模板

9.1 定义学生结构体

1
struct Student
2
{
3
    int num;
4
    char name[20];
5
    float score;
6
};

9.2 遍历结构体数组

1
int i;
2
for (i = 0; i < n; i++) {
3
    printf("%d %s %.1f\n", stu[i].num, stu[i].name, stu[i].score);
4
}

9.3 结构体指针访问成员

1
struct Student *p = &stu;
2
printf("%d\n", p->num);

9.4 链表结点模板

1
struct Node
2
{
3
    int data;
4
    struct Node *next;
5
};

9.5 释放链表

1
void free_list(struct Node *head)
2
{
3
    struct Node *p;
4
    while (head != NULL)
5
    {
6
        p = head;
7
        head = head->next;
8
        free(p);
9
    }
10
}

9.6 结构体类型别名

1
typedef struct Student
2
{
3
    int num;
4
    char name[20];
5
    float score;
6
} Student;

10. 本章最容易错的点

定义完结构体类型后，忘记最后的分号。
把“结构体类型定义”和“结构体变量定义”混成一件事。
访问普通结构体变量成员时误写成 ->。
访问结构体指针成员时误写成 .。
写 (*p).num 时漏掉括号，写成 *p.num。
把结构体数组和普通数组的访问规则搞混。
链表插入、删除时没有把 next 指针接好。
申请了链表结点空间却忘记 free。
把共用体误以为结构体，认为所有成员能同时独立保存值。
枚举常量当成字符串来理解。

11. 手写题

写结果题

写出下面程序的输出结果。

1
#include <stdio.h>
2

3
struct Student
4
{
5
    int num;
6
    float score;
7
};
8

9
int main(void)
10
{
11
    struct Student stu = {1001, 95.5f};
12
    printf("%d %.1f\n", stu.num, stu.score);
13
    return 0;
14
}

答案：

1
1001 95.5

解析：

stu.num 是 1001，stu.score 是 95.5f。格式 %.1f 表示保留 1 位小数。

易错点：

普通结构体变量访问成员用 .。

写出下面程序的输出结果。

1
#include <stdio.h>
2

3
struct Date
4
{
5
    int year;
6
    int month;
7
    int day;
8
};
9

10
int main(void)
11
{
12
    struct Date d1 = {2026, 4, 20};
13
    struct Date d2;
14
    d2 = d1;
15
    printf("%d-%d-%d\n", d2.year, d2.month, d2.day);
16
    return 0;
17
}

答案：

1
2026-4-20

解析：

结构体变量可以整体赋值：

1
d2 = d1;

赋值后，d2 的每个成员都和 d1 对应成员相同。

易错点：

同类型结构体变量之间可以整体赋值。

写出下面程序的输出结果。

1
#include <stdio.h>
2

3
struct Student
4
{
5
    int num;
6
    float score;
7
};
8

9
int main(void)
10
{
11
    struct Student stu = {1001, 90.0f};
12
    struct Student *p = &stu;
13
    p->score = 95.0f;
14
    printf("%.1f\n", stu.score);
15
    return 0;
16
}

答案：

1
95.0

解析：

p 指向 stu，所以：

1
p->score = 95.0f;

等价于：

1
(*p).score = 95.0f;

它会直接修改 stu.score。

易错点：

结构体指针访问成员用 ->。

写出下面程序的输出结果。

1
#include <stdio.h>
2

3
enum Weekday
4
{
5
    MON,
6
    TUE,
7
    WED
8
};
9

10
int main(void)
11
{
12
    enum Weekday day = TUE;
13
    printf("%d\n", day);
14
    return 0;
15
}

答案：

1
1

解析：

枚举常量默认从 0 开始依次递增：

1
MON = 0
2
TUE = 1
3
WED = 2

所以 TUE 的值是 1。

易错点：

枚举常量默认是整数，不是字符串。

写出下面程序的输出结果。

1
#include <stdio.h>
2

3
typedef int Integer;
4

5
int main(void)
6
{
7
    Integer a = 10;
8
    Integer b = 20;
9
    printf("%d\n", a + b);
10
    return 0;
11
}

答案：

1
30

解析：

typedef int Integer; 表示给 int 起了一个别名 Integer。所以：

1
Integer a = 10;
2
Integer b = 20;

等价于：

1
int a = 10;
2
int b = 20;

输出 10 + 20 = 30。

易错点：

typedef 只是起别名，不是创造一种完全不同的运算规则。

写出下面程序的输出结果。

1
#include <stdio.h>
2

3
union Data
4
{
5
    int i;
6
    char c;
7
};
8

9
int main(void)
10
{
11
    union Data x;
12
    x.c = 'A';
13
    printf("%c\n", x.c);
14
    return 0;
15
}

答案：

1
A

解析：

给共用体成员 x.c 赋值为 'A'，紧接着输出 x.c，所以输出 A。

易错点：

共用体所有成员共用同一块内存，同一时间通常只安全使用最后赋值的那个成员。

手写程序题

定义一个结构体 Student，包含学号、姓名、成绩三个成员。

答案：

1
struct Student
2
{
3
    int num;
4
    char name[20];
5
    double score;
6
};

易错点：

结构体定义最后的 } 后面要写分号。

定义一个结构体变量，给它赋值并输出。

答案：

1
#include <stdio.h>
2

3
struct Student
4
{
5
    int num;
6
    char name[20];
7
    double score;
8
};
9

10
int main(void)
11
{
12
    struct Student stu = {1001, "Tom", 90.5};
13

14
    printf("%d %s %.1f\n", stu.num, stu.name, stu.score);
15
    return 0;
16
}

易错点：

普通结构体变量访问成员用 .。

定义一个结构体 Date，保存年月日，并输出一个日期。

答案：

1
#include <stdio.h>
2

3
struct Date
4
{
5
    int year;
6
    int month;
7
    int day;
8
};
9

10
int main(void)
11
{
12
    struct Date d = {2026, 5, 22};
13

14
    printf("%d-%d-%d\n", d.year, d.month, d.day);
15
    return 0;
16
}

易错点：

初始化顺序要和成员定义顺序一致。

定义两个同类型结构体变量，练习整体赋值。

答案：

1
struct Date d1 = {2026, 5, 22};
2
struct Date d2;
3

4
d2 = d1;

易错点：

只有同类型结构体变量之间才能这样整体赋值。

定义一个包含 5 个学生信息的结构体数组，并输出全部内容。

答案：

1
#include <stdio.h>
2

3
struct Student
4
{
5
    int num;
6
    char name[20];
7
    double score;
8
};
9

10
int main(void)
11
{
12
    struct Student stu[5] = {
13
        {1001, "Tom", 90},
14
        {1002, "Jack", 85},
15
        {1003, "Lucy", 92},
16
        {1004, "Lily", 88},
17
        {1005, "Bob", 76}};
18
    int i;
19

20
    for (i = 0; i < 5; i++) {
21
        printf("%d %s %.1f\n", stu[i].num, stu[i].name, stu[i].score);
22
    }
23

24
    return 0;
25
}

易错点：

结构体数组元素访问成员：stu[i].成员名。

在结构体数组中找出成绩最高的学生。

答案：

1
int max_index = 0;
2
int i;
3

4
for (i = 1; i < 5; i++) {
5
    if (stu[i].score > stu[max_index].score) {
6
        max_index = i;
7
    }
8
}
9

10
printf("%d %s %.1f\n", stu[max_index].num, stu[max_index].name, stu[max_index].score);

易错点：

可以保存“最高分学生的下标”，不要只保存最高分，否则后面不好输出整个学生信息。

在结构体数组中计算所有学生的平均成绩。

答案：

1
double sum = 0;
2
double avg;
3
int i;
4

5
for (i = 0; i < 5; i++) {
6
    sum += stu[i].score;
7
}
8

9
avg = sum / 5;
10
printf("%.2f\n", avg);

易错点：

平均分建议用 double。

写函数输出一个学生的信息，参数为结构体变量。

答案：

1
void print_student(struct Student stu)
2
{
3
    printf("%d %s %.1f\n", stu.num, stu.name, stu.score);
4
}

易错点：

传结构体变量会复制一份数据，函数里改它不会影响外面的原变量。

写函数修改一个学生的成绩，参数为结构体指针。

答案：

1
void change_score(struct Student *p, double score)
2
{
3
    p->score = score;
4
}

易错点：

参数是结构体指针时，访问成员用 ->。
传地址后，函数里可以修改外面的结构体变量。

写函数交换两个结构体变量中的成绩。

答案：

1
void swap_score(struct Student *a, struct Student *b)
2
{
3
    double t;
4

5
    t = a->score;
6
    a->score = b->score;
7
    b->score = t;
8
}

易错点：

如果要修改两个结构体变量本身的成员，建议传结构体指针。

定义结构体指针，并分别用 (*p).成员 和 p->成员 输出内容。

答案：

1
struct Student stu = {1001, "Tom", 90.5};
2
struct Student *p = &stu;
3

4
printf("%d %s %.1f\n", (*p).num, (*p).name, (*p).score);
5
printf("%d %s %.1f\n", p->num, p->name, p->score);

易错点：

(*p).num 的括号不能省。
p->num 是更常用的写法。

定义一个表示长方形的结构体，包含长和宽，写函数求面积。

答案：

1
struct Rect
2
{
3
    double length;
4
    double width;
5
};
6

7
double area(struct Rect r)
8
{
9
    return r.length * r.width;
10
}

易错点：

长和宽可能是小数，用 double 更灵活。

定义一个表示复数的结构体，包含实部和虚部，写函数输出它。

答案：

1
struct Complex
2
{
3
    double real;
4
    double imag;
5
};
6

7
void print_complex(struct Complex c)
8
{
9
    printf("%.2f + %.2fi\n", c.real, c.imag);
10
}

易错点：

复数的实部和虚部是两个相关数据，适合用结构体打包。

定义一个链表结点结构体，包含数据域和指针域。

答案：

1
struct Node
2
{
3
    int data;
4
    struct Node *next;
5
};

易错点：

链表结点里必须有一个指向同类型结点的指针。

手动建立一个 3 个结点的链表，并输出所有结点数据。

答案：

1
#include <stdio.h>
2
#include <stdlib.h>
3

4
struct Node
5
{
6
    int data;
7
    struct Node *next;
8
};
9

10
int main(void)
11
{
12
    struct Node a = {1, NULL};
13
    struct Node b = {2, NULL};
14
    struct Node c = {3, NULL};
15
    struct Node *p;
16

17
    a.next = &b;
18
    b.next = &c;
19

20
    p = &a;
21
    while (p != NULL)
22
    {
23
        printf("%d ", p->data);
24
        p = p->next;
25
    }
26

27
    return 0;
28
}

易错点：

链表靠 next 把一个结点接到下一个结点。
遍历时条件是 p != NULL。

写函数统计链表中结点个数。

答案：

1
int count_nodes(struct Node *head)
2
{
3
    int count = 0;
4

5
    while (head != NULL)
6
    {
7
        count++;
8
        head = head->next;
9
    }
10

11
    return count;
12
}

易错点：

每经过一个结点，计数加 1，并移动到下一个结点。

在链表头部插入一个新结点。

答案：

1
struct Node *insert_head(struct Node *head, struct Node *new_node)
2
{
3
    new_node->next = head;
4
    return new_node;
5
}

易错点：

头插后，新结点会变成新的头结点，所以要返回 new_node。

在链表中间某个结点后插入新结点。

答案：

1
void insert_after(struct Node *pos, struct Node *new_node)
2
{
3
    new_node->next = pos->next;
4
    pos->next = new_node;
5
}

易错点：

一定要先让新结点指向原来的后继结点，再让前一个结点指向新结点。
两句顺序反了，容易把后面的链表弄丢。

删除链表中值为 x 的第一个结点。

答案：

1
struct Node *delete_first(struct Node *head, int x)
2
{
3
    struct Node *p = head;
4
    struct Node *prev = NULL;
5

6
    while (p != NULL && p->data != x)
7
    {
8
        prev = p;
9
        p = p->next;
10
    }
11

12
    if (p == NULL) {
13
        return head;
14
    }
15

16
    if (prev == NULL) {
17
        head = p->next;
18
    }
19
    else {
20
        prev->next = p->next;
21
    }
22

23
    free(p);
24
    return head;
25
}

易错点：

删除头结点时要单独处理，因为头指针会变化。
动态申请的结点删除后要 free。

写函数释放整个链表。

答案：

1
void free_list(struct Node *head)
2
{
3
    struct Node *p;
4

5
    while (head != NULL)
6
    {
7
        p = head;
8
        head = head->next;
9
        free(p);
10
    }
11
}

易错点：

要先保存当前结点，再移动 head，最后释放当前结点。

定义一个共用体，包含 int、char、float 三种成员，并练习赋值输出。

答案：

1
#include <stdio.h>
2

3
union Data
4
{
5
    int i;
6
    char c;
7
    float f;
8
};
9

10
int main(void)
11
{
12
    union Data d;
13

14
    d.i = 100;
15
    printf("%d\n", d.i);
16

17
    d.c = 'A';
18
    printf("%c\n", d.c);
19

20
    d.f = 3.14f;
21
    printf("%.2f\n", d.f);
22

23
    return 0;
24
}

易错点：

共用体成员共用同一块内存，后赋值的成员会影响之前成员的内容。

定义一个枚举类型表示星期，并输出某一天对应的整数值。

答案：

1
#include <stdio.h>
2

3
enum Weekday
4
{
5
    MON,
6
    TUE,
7
    WED,
8
    THU,
9
    FRI,
10
    SAT,
11
    SUN
12
};
13

14
int main(void)
15
{
16
    enum Weekday day = FRI;
17

18
    printf("%d\n", day);
19
    return 0;
20
}

易错点：

默认 MON = 0，所以 FRI = 4。

用枚举类型表示成绩等级，例如 A、B、C、D。

答案：

1
enum Grade
2
{
3
    A,
4
    B,
5
    C,
6
    D
7
};

易错点：

枚举常量是标识符，不是字符。这里的 A 不是 'A'。

用 typedef 给结构体类型起别名，并定义变量。

答案：

1
typedef struct Student
2
{
3
    int num;
4
    char name[20];
5
    double score;
6
} Student;
7

8
Student stu = {1001, "Tom", 90.5};

易错点：

起别名后可以直接写 Student stu;，不用每次都写 struct Student stu;。

用 typedef 给指针类型起别名。

答案：

1
typedef int *IntPtr;
2

3
IntPtr p1, p2;

解析：

这里 p1 和 p2 都是 int *。

易错点：

如果不用 typedef，写 int *p1, p2; 时只有 p1 是指针，p2 是普通 int。

改错题

找出并改正下面程序中的错误。

1
struct Student
2
{
3
    int num;
4
    float score;
5
}

答案：

错误原因：

结构体类型定义结尾缺少分号。

正确写法：

1
struct Student
2
{
3
    int num;
4
    float score;
5
};

易错点：

struct 定义结束的 } 后面必须写 ;。

找出并改正下面程序中的错误。

1
struct Student
2
{
3
    int num;
4
    float score;
5
};
6

7
int main(void)
8
{
9
    struct Student stu;
10
    struct Student *p = &stu;
11
    p.num = 1001;
12
    return 0;
13
}

答案：

错误原因：

p 是结构体指针，访问成员不能写：

1
p.num = 1001;

正确写法：

1
p->num = 1001;

完整修正：

1
int main(void)
2
{
3
    struct Student stu;
4
    struct Student *p = &stu;
5

6
    p->num = 1001;
7

8
    return 0;
9
}

易错点：

普通结构体变量用 .。
结构体指针用 ->。

找出并改正下面程序中的错误。

1
struct Student
2
{
3
    int num;
4
    float score;
5
};
6

7
int main(void)
8
{
9
    struct Student stu;
10
    struct Student *p = &stu;
11
    printf("%d\n", *p.num);
12
    return 0;
13
}

答案：

错误原因：

1
*p.num

会先把 . 和 num 结合，等价于：

1
*(p.num)

但 p 是指针，不是结构体变量，所以错误。

正确写法一：

1
printf("%d\n", (*p).num);

正确写法二：

1
printf("%d\n", p->num);

完整修正：

1
#include <stdio.h>
2

3
struct Student
4
{
5
    int num;
6
    float score;
7
};
8

9
int main(void)
10
{
11
    struct Student stu = {1001, 90.0f};
12
    struct Student *p = &stu;
13

14
    printf("%d\n", p->num);
15

16
    return 0;
17
}

易错点：

(*p).num 里的括号很重要。
更推荐初学者写 p->num。

找出并改正下面程序中的错误。

1
union Data
2
{
3
    int i;
4
    char c;
5
};
6

7
int main(void)
8
{
9
    union Data x;
10
    x.i = 100;
11
    x.c = 'A';
12
    printf("%d %c\n", x.i, x.c);
13
    return 0;
14
}

答案：

问题说明：

这段代码语法上可能能编译，但逻辑上有问题：共用体 union 的所有成员共用同一块内存。先给 x.i 赋值，再给 x.c 赋值，后一次赋值会覆盖同一块内存的一部分或全部，因此再输出 x.i 的结果不可靠。

如果想同时保存 i 和 c，应该用结构体：

1
#include <stdio.h>
2

3
struct Data
4
{
5
    int i;
6
    char c;
7
};
8

9
int main(void)
10
{
11
    struct Data x;
12

13
    x.i = 100;
14
    x.c = 'A';
15

16
    printf("%d %c\n", x.i, x.c);
17
    return 0;
18
}

如果只是练习共用体，就应该只输出最后赋值的成员：

1
union Data x;
2
x.c = 'A';
3
printf("%c\n", x.c);

易错点：

结构体的成员各自有独立存储空间。
共用体的成员共用同一块存储空间，不能同时独立保存多个成员值。

12. 自测清单

我知道结构体是把多个相关数据打包成一个整体。
我会定义结构体类型，也会定义结构体变量。
我会用 . 访问普通结构体变量成员。
我会用 -> 访问结构体指针成员。
我知道结构体作函数参数时，什么时候传变量，什么时候传地址。
我知道链表结点最关键的成员是数据域和 next 指针。
我知道共用体和结构体最大的区别。
我知道 enum 和 typedef 最基本的用途。

13. 学习建议

第 8 章最重要的，不是一下子会写所有链表题，而是先建立“数据是怎么组织起来的”这个感觉。
结构体题一定要多写输出语句，不要只定义不看结果。
一看到 .、->、(*p).成员，就先想清楚当前手里拿的是“变量”还是“指针”。
链表题先画图，再写代码，尤其是插入和删除。
共用体、枚举、typedef 先掌握最基本用法，不要一开始钻太深。

学完这一章后，你就不再只是“处理单个数据”，而是开始学会把一整类相关数据组织起来了。这一步对后面的链表、文件、项目练习都很重要。

第 8 章 结构体与共用体

对应教材目录

本章目标

1. 为什么要学结构体与共用体

2. 结构体概述

2.1 结构体类型的定义

2.2 结构体变量的定义

2.3 结构体变量的引用

2.4 结构体变量的赋值和初始化

3. 结构体数组

4. 指向结构体的指针

4.1 指向结构体的指针变量的定义

4.2 利用结构体指针变量引用成员

4.3 用结构体类型作函数参数

5. 用结构体处理链表

5.1 链表概述

5.2 链表的建立与输出

5.3 链表的插入

5.4 链表的删除

5.5 链表的综合操作

6. 共用体

6.1 共用体类型及变量的定义

6.2 共用体变量的引用

7. 枚举类型

8. 用 typedef 定义类型别名

9. 本章常见模板

9.1 定义学生结构体

9.2 遍历结构体数组

9.3 结构体指针访问成员

9.4 链表结点模板

9.5 释放链表

9.6 结构体类型别名

10. 本章最容易错的点

11. 手写题

写结果题

手写程序题

改错题

12. 自测清单

13. 学习建议

第 8 章结构体与共用体

8. 用 `typedef` 定义类型别名