第十一章 结构体与共用体
11.1 概 述
数据的基本类型：整型、实型、字符型等
构造类型：数组
如何描述一个学生的基本信息?
学号, 名称, 性别, 年龄, 成绩, 地址
C语言提供了这样一种数据结构,结构体 （ structure)
它相当于, 记录, 。
num name sex age score addr
10010 LiFun M 18 87.5 Beijing
例如, struct student
｛ int num;
char name[20]；
char sex;
int age；
float score；
char addr[30]；
};
定义一个结构体类型的一般形式为,
struct 结构体名
{
成员表列
}；
, 成员表列, 对各成员都应进行类型说明，即,
类型标识符 成员名；
也可以把, 成员表列, 称为, 域表,,每一个成员
称为结构体中的一个域。
１ 1.2 定义结构体类型变量的方法
要定义一个结构体类型的变量, 可以采取以
下三种方法 。
一, 先定义 结构体类型 再定义 变量名
如已定义 结构体类型 struct student,可以
用它来定义变量,
struct student student1,student2；
为了使用方便，人们通常用一个符号常量代表一个结构
体类型。在程序开头，用
＃ define STUD struct student -预处理命令
在程序中,STUD与 struct student完全等效 。
STUD
｛ int num;
char name[20]；
char sex;
int age；
float score；
char addr[30]；
};
可以直接用 STUD定义变量,
STUD student1,student2；
二、在定义类型的同时定义变量
例如,struct student
｛ int num;
char name[20];
char sex;
int age;
float score;
char addr[30];
} student1,student2；
既定义了类型，又定义了两个 struct student类型的
变量 student1,student2。
三、直接定义结构类型变量
其一般形式为,
struct --无结构体名
{
成员表列
}
变量名表列；
关于结构体类型，有几点要说明,
１．类型与变量是不同的概念,
只能对变量赋值、存取或运算，而不能对类型赋值、
存取或运算。
在编译时，对类型是不分配空间的，只对变量分
配空间。
2,对结构体中的成员（即, 域, ），可以单独使用，
它的作用与地位相当于普通变量；
strcpy(student1.name,”zhang”)
3,成员名可以与程序中的变量名相同；
4．成员也可以是一个结构体变量。
如,struct date
｛ int month;
int day;
int year; };
struct student
{ int num;
char name［２０ ];
char sex;
int age;
struct date birthday；
char addr[３０ ];
｝ student1,student2；
说明：先定义一个结构体ｄａ tｅ类型，它代表, 日
期,,包括三个成员。
１ 1.３ 结构体类型变量的引用
引用方式,结构体变量名,成员名
student.num=10010；
注：, ·”是成员（分量）运算符，它在所有的运算
符中优先级最高。
引用结构体变量应遵守以下规则,
１, 不能将一个结构体变量作为一个整体进行
输入和输出 。
printf(”%d,%s,%c,%d,%f,%s\n,”,student1)；
只能对结构体变量中的各个成员分别输出。
２ ·如果成员本身又属一个结构体类型，则要用
若干个成员运算符，一级一级地找到最低的
一级的成员。只能对最低级的成员进行赋值
或存取以及运算。
student1.num
student1.name
student1.birthday.month
Student1.birthday.day
Student1.birthday.year
注意,不能用 student1.birthday 来访问 student1变
量中的成员 birthday，因为 birthday本身是一个结
构体变量。
３．对成员变量可以像普通变量一样进行各种
运算（根据其类型决定可以进行的运算）。
例如,
student2.score=student1.score；
sum=student1.score+student2.score；
student1.age++；
++student1.age；
４．可以引用成员的地址，也可以引用结构体
变量的地址。
例如,
scanf（ "％ d”,&student1.num）；
（输入 student1.num的值）
printf（, %o”,&student1）；
（输出 student1的首地址）
11．４ 结构体变量的初始化
例如,
Struct student
｛ long int num；
char name[20]；
char sex；
char addr［ 20]；
}ａ＝ {20034101,,Lilin”,?M?,“WS Road”};
在定义时赋初值。
例 1 p264_b1
１ 1.５ 结构体数组
定义,数组中的每一个元素是结构体, 则该
数组是结构体数组 。
例如,
struct student
｛ int num；
char name[20]；
char sex；
int age；
float score；
char addr[30]；
}；
struct student stu[3]；
二、结构体数组的初始化
如,struct student
{ int num；
char name[20]；
char sex；
int age；
float score；
char add[30]；
｝
Stu[3]={{1,“ZHANG,,?Ｍ ’,18,87.5,“WS
Road"},{…},{…}}；
三、举例
p266_b2
１ 1.６ 指向结构体类型数据的指针
一个结构体变量的指针就是该变量所占据的内存段的起始地址 。
11.6.1 指向结构体变量的指针
例 3 ＃ include,string.h"
main()
{ struct student
{long int num;
char name[２０ ]；
char sex;
float score； };
struct student stu_1,*p;
ｐ =&stu_1;
stu_1.num=89101
strcpy(stu_1.name,” Ｌｉ lｉｎ, ）；
stu_1.sex=?Ｍ ’ ；
stu_1.score＝８９,5；
printf(”No:％ ld＼ nname:％ s\nsex:％ c\ｎ score:％
f\n”,stu_1.num,stu_1.name,stu_1.sex，
stu_1.score） ;
printf("\nNo.:%1d\nname:%s\nsex:%c\nscore:%f\n",
(*p).num,(*p).name,(*.p).sex,(*p).score);
} p 89101
“Lilin”
?M?
89.5
说明,
（ *p）表示ｐ指向的结构体变量,
(*p).num 是ｐ指向的结构体变量中的成员 num。
*p.num 表示？
在Ｃ语言中，可以把 (*p).num用 ｐ ->ｎｕｍ 来代替，
表示ｐ所指向的结构体变量中的ｎｕｍ成员 。
①结构体变量,成员名；
② (*ｐ ).成员名；
③ｐ ->成员名
ｐ ->ｎ＋＋ 得到ｐ指向的结构体变量中的成员ｎ的
值, 用完该值后使它加１ 。
＋＋ｐ ->ｎ 得到ｐ指向的结构体变量中的成员ｎ的
值使之加１ （ 先加 ） 。
11,6．２指向结构体数组的指针
［例 11.４］
struct student
{ int num;
char name[２０］；
char sex;
int age； }；
struct student stu［３］ ={
{{10101,” Ｌｉ Ｌｉｎ,, ‘ Ｍ ’,１８｝,
{101０ 2,” Ｚｈａｎｇ Ｆｕｎ,, ’ Ｍ ‘,19},
{10104,"wang Min",?F?,20}};
main()
{ struct student *p；
printf(”No,Name sex age\n”）；
for（ｐ =stu； p＜ stu+３；ｐ ++）
printf（, %5d%-20s%2c%4d\n”,
p->num,p->name,p->sex,p->age）；
}
１ 1.６,３用指向结构体的指针作函数参数
如何传递一个结构体变量的值给函数?
方法一,用结构体变量的成员作参数。
方法二,用结构体变量作实参。
方法三,用指向结构体变量的指针作实参。
例 5
１ 1．７ 用指针处理链表
１ 1．７,1链表概述
链表是一种常见的重要的数据结构。它是动态地进
行存储分配的一种结构。我们知道，用数组存放数据
时,
必须事先定义固定的长度 （ 即元素个数 ） 。 比如, 有的
班级有１００人, 而有的班只有３０人, 如果要用同
一个数组先后存放不同班级的学生数据, 则必须定义
长度为 100的数组 。 如果事先难以确定一个班的最多
人数, 则必须把数组定得足够大, 以能存放任何班级
的学生数据 。 显然这将会浪费内存 。 链表则没有这种
缺点, 它根据需要开辟内存单元 。 图１０, １１表示
最简单的一种链表 （ 单向链表 ） 的结构 。 链表有一个
,头指针, 变量, 图中以ｈｅａｄ表示, 它存放一个
地址 。
该地址指向一个元素。链表中每一个元素称为, 结点,,
每个结点都应包括两个部分：一为用户需要用的实际
数据，二为下一个结点的地址。课以看出,head指向
第一个元素；第一个元素又指向第二个元素； ……，
直到最后一个元素，该元素不再指向其它元素，它称
为 ‘ 表尾,,它的地址部分放一个, ＮＵＬＬ, （表
示, 空地址, ）。链表到此结束。
可以看到：链表中各元素在内存中可以不是连续存
放的。要找某一元素，必须先找到上一个元素，根据
它提供的下一元素地址才能找到下一个元素。
如果不提供, 头指针, （ head），则整个链表都无法访
问。链表如同一条铁链一样，一环扣一环，中间是不
能断开的。打个通俗的比方：幼儿园的老师带领孩子
出来散步，老师牵着第一个小孩的手，第一个小孩的
另一只手牵着第二个孩子,……，这就是一个, 链,,
最后一个孩子有一只手空着，他是, 链尾, 。要找这
个队伍，必须先找到老师，然后顺序找到每一个孩子。
可以看到，这种链表的数据结构，必须利用指针变
量才能实现
。即：一个结点中应包含一个指针变量，用它存放下一
结点的地址。
前面介绍了结构体变量, 它包含若干成员 。 这些成
员可以是数值类型, 字符类型, 数组类型, 也可以是
指针类型 。 这个指针类型可以是指向其它结构体类型
数据, 也可以指向它所在的结构体类型 。 例如,
sｔｒｕｃｔ sｔｕｄｅｎｔ
｛ ｉｎｔ ｎｕｍ ;
ｆｌｏａｔ ｓ coｒｅ ;
ｓｔｒｕｃｔ ｓｔｕｄｅｎｔ *ｎｅｘｔ ;
ｎｅ xt是成员名，它是指针类型的，它指向ｓｔｒ
ｕｃｔ ｓｔｕｄｅｎｔ类型数据（这就是ｎｅｘｔ
所在的结构体类型）。用这种方法可以建立链表。见
图１０．１２。
其中每一个结点都属于ｓ tｒｕｃ t ｓｔｕｄｅｎ
t类型，它的成员ｎｅｘ t存放下一结点的地址，程序
设计人员可以不必具体知道地址值,
只要保证将下一个结点的地址放到前一结点的成员ｎｅ
xt中即可。
请注意：上面只是定义了一个ｓｔｒｕｃｔ ｓｔ
ｕｄｅｎｔ类型，并未实际分配存储空间。前面讲过，
链表结构是动态地分配存储的，即在需要时才开辟一
个结点的存储单元。怎样动态地开辟和释放存储单元
呢？Ｃ语言编译系统的库函数提供了以下有关函数。
１,ｍａｌｌｏｃ（ｓｉｚｅ） 在内存的动态存
储区中分配一个长度为ｓｉｚｅ的连续空间。
此函数的值（即, 返回值 "）是一个指针，它的值是该
分配域的起始地址。如果此函数未能成功地执行，则
返回值为０。
２,calloc(n,size) 在内存的动态区存储中分配ｎ
个长度为ｓｉｚｅ的连续空间。函数返回分配域的起
始地址；如果分配不成功，返回０。
３,free(ptr) 释放由ｐｔｒ指向的内存区。ｐｔ
ｒ是最近一次调用ｃａ１１或ｍａ１１ｏｃ函数时返
回的值。
上面三个函数中，参数ｎ和ｓｉｚｅ为整型，ｐｔ
ｒ为字符型指针。
请注意：许多Ｃ版本提供的 malloｃ和 call０ｃ函数得
到的是指向字符型数据的指针。新标准Ｃ提供的ｍａ
１１０ｃ和ｃａ１１ oc函数规定为ｖｏｉｄ *类型。
有了本节所介绍的初步知识，下面就可以对链表进
行操作了（包括建立链表、插入或删除链表中一个结
点等）。有些概念需要在后面的应用中逐步建立和掌
握。
１ 1．７．２建立链表
所谓建立链表是指从无到有地建立起一个链表，即一个
一个地输入各结点数据，并建立起前后相链的关系。
下面通过一个例子来说明如何建立一个链表。
［例１ 1．７］写一函数建立一个有５名学生数据
的单向链表。
先考虑实现此要求的算法（见图１０,１３）。
设三个指针变量：ｈ eａｄ、ｐ１、ｐ２，它们都
指向结构体类型数据。先用ｍａｌ１ｏｃ函数开辟一
个结点，并使ｐ１、ｐ２指向它。
然后从键盘读人一个学生的数据给ｐｌ所指的结点。我
们约定学号不会为零，如果输入的学号为０，则表示
建立链表的过程完成，该结点不应连接到链表中。先
使ｈｅａｄ的值为ＮＵ LL（即等于０），这是链表为
,空, 时的情况（即ｈｅａｄ不指向任何结点，链表
中无结点），以后增加一个结点就使ｈｅａｄ指向该
结点。
如果输入的ｐｌ一 >ｎｕｍ不等于０，而且输入的是
第一个结点数据（ｎ =１）时，则令ｈｅａｄ＝ｐ１,
即把ｐ 1的值赋给ｈｅａｄ，也就是使ｈｅａｄ也指向
新开辟的结点（图１０．１４）。 P1所指向的新开
辟的结点就成为链表中第一个结点。然后再开辟另一
个结点并使ｐ１指向它，接着读入该结点的数据（见
图１０．１５（ａ））。如果输入的 p1->ｎｕｍ !=０，
则应链入第２个结点（ｎ＝２），由于ｎ !=１，则将
p1的值赋给 p2-->next,也就是使第一个结点的ｎｅｘ t
成员指向第二个结点（见图１０．１５（ b））。接
着使 p2=ｐ１,
也就是使ｐ２指向刚才建立的结点，见图１０．１５
（ｃ）。再开辟一个结点并使ｐｌ指向它，并读入该
结点的数据（见图１０．１６（ａ）），在第三次循
环中，由于ｎ＝３（ｎ !=１），又将ｐｌ的值赋给ｐ
２一 >next，也就是将第３个结点连接到第２个结点
之后，并使ｐ２ =ｐ１，使ｐ２指向最后一个结点
（见图１ 1.１６（ b）。
再开辟一个新结点，并使ｐｌ指向它,
输入该结点的数据（见图１ 1．１７（ａ））。由于ｐ
ｌ一 >ｎｕｍ的值为０，不再执行循环，此新结点不
应被连接到链表中。此时将ＮＵＬＬ赋给ｐ２一 >ｎ
ｅｘｔ，见图１０．１７（ b)。建立链表过程至此结
束，ｐｌ最后所指的结点未链入链表中，第３个结点
的ｎｅｘｔ成员的值为ＮＵＬＬ，它不指向任何结点。
虽然ｐｌ指向新开辟的结点，但从链表中无法找到该
结点。
建立链表的函数可以如下,
＃ｄ efine ＮＵＬＬ ０
＃ｄｅｆｉｎｅ ＬＥＮ ｓｉｚｅｏ f(ｓｔｒｕｃｔ
ｓｔｕ dent）
ｓｔｒｕｃｔ ｓｔｕｄ eｎｔ
｛１ｏｎ g ｎｕｍ ;
ｆ lｏａｔ ｓｃｏｒｅ；
sｔｒｕｃｔ sｔｕｄｅｎｔ *ｎｅ xｔ ;
};
ｉｎｔ ｎ ;
ｓｔｒｕｃｔ ｓｔｕｄｅｎｔ *ｃｒｅａｔ（）
／ *此函数带回一个指向链表头的指针 *／
｛ｓｔｒｕｃｔ ｓｔｕｄｅｎｔ *ｈｅａｄ；
ｓｔｒｕｃｔ ｓｔｕｄｅｎｔ ＊ p1,*ｐ２；
ｎ＝０ ;
p1=p2=（ｓｔｒｕｃｔ ｓｔｕｄｅｎｔ *）ｍａ
ｌ１ｏｃ（ＬＥＮ）；／ *开辟一个新单元 *／
ｓｃａｎｆ（ "％ ld，％ f"，＆ pl一 >ｎｕｍ，＆ p
ｌ一 >ｓｃｏｒｅ）；
ｈｅａｄ＝ＮＵＬＬ,
ｗｈｉｌｅ （ｐｌ一 >ｎｕｍ！＝０）
｛ｎ =ｎ十１；
ｉｆ（ｎ＝＝１） ｈｅａｄ＝ｐｌ；
ｅｌｓｅ ｐ２一 >ｎｅｘｔ＝ｐ１；
ｐ２ =ｐｌ；
ｐｌ＝（ｓｔｒｕｃｔ ｓｔｕｄｅｎｔ *）
ｍａｌｌｏｃ（ＬＥＮ）；
ｓｃａｎｆ（ "%1d，％ f"，＆ p1-->ｎｕｍ，＆ｐｌ一 >
ｓｃｏｒｅ）；
}
ｐ２一 >ｎｅｘｔ＝ＮＵ LＬ；
ｒｅｔｕｒｎ（ｈｅａｄ） ;
}
请注意,
（１）第一行为 #ｄｅｆｉｎｅ命令行，令ＮＵＬ
Ｌ代表０，用它表示, 空地址, 。第二行令ＬＥＮ代
表ｓｔｒｕｃｔ ｓｔｕｄｅｎｔ结构体类型数据的
长度,
ｓｉｚｅｏｆ是, 求字节数运算符, 。
（２）第９行定义一个ｃｒｅａｔ函数，它是指针
类型，即此函数带回一个指针值，它指向一个ｓｔｒ
ｕｃｔ ｓｔ uｄｅｎｔ类型数据。实际上此ｃｒｅ
ａｔ函数带回一个链（３）ｍａｌｌｏｃ（ＬＥＮ）
的作用是开辟一个长度为ＬＥＮ的内存区，ＬＥＮ已
定义为ｓｉｚｅｏｆ（ｓｔｒｕｃｔ ｓｔｕｄｅｎ
ｔ），即结构体ｓｔｒｕｃｔ ｓｔｕｄｅｎｔ的长
度。在一般系统中，ｍａｌｌｏｃ带回的是指向字符
型数据的指针。
而ｐ１、ｐ２是指向ｓｔｒｕｃｔ ｓｔｕｄｅｎｔ类
型数据的指针变量，二者所指的是不同类型的数据，
这是不行的。因此必须用强制类型转换的方法使之类
型一致，在ｍａｌｌｏｃ （ＬＥＮ）之前加了
,（ｓｔｒｕｃｔ ｓｔｕｄｅｎｔ *）,,它的作
用是使ｍａｌｌｏｃ返回的指针转换为指向ｓｔｒｕ
ｃｔ ｓｔｕｄｅｎｔ类型数据的指针。注意, *”
号不可省略，否则变成转换成ｓｔｒｕｃｔ ｓｔｕ
ｄｅｎｔ类型了，而不是指针类型了。
（４）最后一行ｒｅｔｕｒｎ后面的参数是ｈｅａｄ
（ｈｅａｄ已定义为指针变量，指向 strｕｃｔ ｓ
ｔｕｄｅｎｔ类型数据）。因此函数返回的是ｈｅａ
ｄ的值，也就是链表的头地址。
（５）ｎ是结点个数。
（６）这个算法的思路是：让ｐｌ指向新开的结点，
ｐ２指向链表中最后一个结点，把ｐｌ所指的结点连
接在 p2所指的结点后面，用, ｐ２一 >ｎｅｘｔ =ｐｌ,
来实现。
我们对建立链表过程作了比较详细的介绍,
读者如果对建立链表的过程比较清楚的话，对下面介绍
的删除和插入过程也就比较容易理解了。
１ 1．７．３输出链麦
将链表中各结点的数据依次输出。这个问题比较容
易处理。首先要知道链表头元素的地址，也就是要知
道ｈｅａｄ的值。然后设一个指针变量 p,先指向第一
个结点，输出ｐ所指的结点，然后使ｐ后移一个结点，
再输出。直到链表的尾结点。
「例１０．８］写出输出链表的函数ｐｒｉｎｔ。
ｖｏｉｄ ｐｒｉｎｔ（ｈｅａｄ）
ｓｔｒｕｃｔ ｓｔｕｄｅｎｔ *ｈｅａｄ ;
｛ｓｔｒｕｃｔ ｓｔｕｄｅｎｔ *ｐ；
ｐｒｉｎｔｆ（, \nNｏｗ，Ｔｈｅｓｅ％ｄ
ｒｅｃｏｒｄｓ aｒｅ：＼ n",n);
ｐ＝ｈｅａｄ；
if（ｈｅａｄ！＝ＮＵＬＬ）
ｄ o
｛ｐｒｉｎｔｆ（ "％ｌｄ％５,１ｆ＼ "，ｐ一 >ｎｕｍ，
ｐ —＞ｓｃｏｒｅ）；
ｐ =ｐ一 >ｎｅｘｔ；
｝ｗｈｉｌｅ（ｐ！ =ＮＵＬＬ）；
算法可用图１ 1．１８表示。
其过程可用图１ 1.１９表示。ｐ先指向第一结点，
在输出完第一个结点之后，ｐ移到图中ｐ '虚线位置，
指向第二个结点。程序中ｐ =ｐ一 >ｎｅｘｔ的作用是：
将ｐ原来所指向的结点中ｎｅｘｔ的值赋给ｐ,
而 p一 >ｎｅｘｔ的值就是第二个结点的起始地址。将它
赋给 p就是使ｐ指向第二个结点。
ｈｅａｄ的值由实参传过来，也就是将已有的链表
的头指针传给被调用的函数，在ｐｒｉｎｔ函数中从
ｈｅａｄ所指的第一个结点出发顺序输出各个结点。
１ 1．７．４ 对链麦的删除操作
已有一个链表，希望删除其中某个结点。怎样考虑
此问题的算法呢，先打个比方,
一队小孩 (Ａ,B.C.D.E）手拉手，如果某一小孩（Ｃ）
想离队有事，而队形仍保持不变。只要将Ｃ的手从两
边脱开，Ｂ改为与 D拉手即可，见图１０,２０。图１
０．２０（ａ）是原来的队伍，图１０,２０（ b)是
ｃ离队后的队伍。
与此相仿, 从一个链表中删去一个结点, 并不是真正
从内存中把它抹掉, 而是把它从链表中分离开来, 即
改变链接关系即可 。
［ 例１ 1,９ ］ 写一函数以删除指定的结点 。
我们以指定的学号作为删除结点的标志。例如，输入８
９１０３表示要求删除学号为８９１０３的结点。解
题的思路是这样的：从ｐ指向的第一个结点开始，检
查该结点中的ｎｕｍ值是否等于输入的要求删除的那
个学号。如果相等就将该结点删除，如不相等，就将
可以设两个指针变量ｐｌ和ｐ２，先使ｐｌ指向
第一个结点（图１０．２ 1（ａ））。如果要删除的
不是第一个结点,
则使ｐｌ后指向下一个结点（将ｐｌ一 >ｎｅｘｔ赋给
ｐｌ），在此之前应将ｐｌ的值赋给ｐ２，使ｐ２指
向刚才检查过的那个结点，见图１０。２１（ b）,如
此一次一次地使ｐ后移，直到找到所要删除的结点或
检查完全部链表都找不到要删除的结点为止。如果找
到某一结点是要删除的结点，还要区分两种情况：①
要删的是第一个结点（ｐｌ的值等于ｈｅａｄ的值，
如图１０,２１（ａ）那样），则应将ｐｌ一 >ｎｅｘ
ｔ赋给ｈｅａｄ。见图１０．２１（ｃ）。
这时 hｅ ad指向原来第二个结点。第一个结点虽然仍存
在，但它已与链表脱离，因为链表中没有一个元素或
头指针指向它。虽然ｐ１还指向它，它仍指向第二个
结点，但仍无济于事，现在链表的第一个结点是原来
第二个结点，原来第一个结点, 丢失, 。②如果要删
除的不是第一个结点，则将ｐｌ一 >ｎｅｘｔ赋给ｐ
２一 >ｎｅｘｔ，见图１０．２１（ d）,ｐ２一 >ｎｅ
ｘｔ原来指向ｐｌ指向的结点（图中第二个结点），
现在ｐ２一 >ｎｅｘｔ改为指向ｐ１一 >ｎｅｘｔ所指
向的结点
（图中第三个结点）。ｐｌ所指向的结点不再是链表的
一部分。
还需要考虑链表是空表（无结点）和链表中找不到
要删除的结点的情况。
图 11。 22表示解此题的算法,
删除结点的函数ｄｅｌ如下,
ｓｔｒｕｃｔ ｓｔｕｄｅｎｔ *ｄｅｌ（ｈｅ
ａｄ，ｎｕｍ）
ｓｔｒｕｃｔ ｓｔｕｄｅｎ t *ｈｅａｄ；
１ｏｎｇ ｎｕｍ；
｛ｓｔｒｕｃｔ ｓ tudent *p1,*p2;
if（ｈｅａｄ =＝ＮＵＬＬ） {ｐｒｉｎｔｆ
（, \nｌｉｓｔ ｎｕｌｌ !\n”）； goto ｅｎ
ｄ；｝
ｐ 1＝ｈｅａｄ；
ｗｈｉ１ｅ （ｎｕｍ！＝ｐｌ一 >ｎｕｍ＆＆
ｐｌ一 >ｎｅｘｔ！一ＮＵＬＬ）／ *ｐｌ指向的不是
所要找的结点，并且后面还有结点点 *／
{ｐ２ =ｐ１；ｐｌ =ｐｌ一 >ｎｅｘｔ；｝／ *
后移一个结点 *／
ｉｆ （ｎｕｍ＝＝ｐｌ一 >ｎｕｍ） ／ *找到了 *／
{ｉｆ （ｎ１＝＝ｈｅａｄ） ｈｅａｄ =ｐ
ｌ一 >ｎｅｘｔ；／ *若ｐｌ指向的是头结点，把第二
个结点地址赋予ｈｅａｄ *／
ｅ１ｓｅ ｐ２一 >ｎｅｘｔ =ｐｌ一 >ｎｅ
ｘｔ；／ *否则将下一结点地址赋给前一结点地址 *\
ｐｒｉｎｔｆ（ "dｅｌｅｔｅ：％ ld\n”，
ｎｕｍ）；
ｎ =n-１；
}
ｅｌｓｅ ｐｒｉｎｔｆ（, ％ｌｄ ｎｏ
ｔ ｂｅｅｎ ｆｏｕｎｄ！ \n“，ｎｕｍ）；／ *
找不到该结点 *／
ｅｎｄ,
ｒｅｔｕｒｎ （ ｈｅａｄ ） ；
}
函数的类型是指向ｓｔｒｕｃｔ ｓｔｕｄｅｎｔ
类型数据的指针,
它的值是链表的头指针。函数参数为ｈｅａｄ和要删除
的学号ｎｕｍ。ｈｅａｄ的值可能在函数执行过程中
被改变（当删除第一个结点时）。
１ 1．７。５对链表的插入操作
将一个结点插入到一个已有的链表中。设已有的链
表中各结点中的成员项ｎｕｍ（学号）是按学号由小
到大顺序排列的。
用指针变量ｐ０指向待插入的结点，ｐｌ指向第一
个结点。见图１０．２３（ａ）。
将ｐ０一 >ｎｕｍ与ｐｌ一 >ｎｕｍ相比较，如果ｐ０一
>ｎｕｍ＞ｐｌ一 >ｎｕｍ，则待插入的结点不应插在
ｐｌ所指的结点之前。此时将ｐｌ后移，并使ｐ２指
向刚才ｐｌ所指的结点，见图１０．２３（ b）。再
将ｐ１一 >ｎｕｍ与ｐ０一 >ｎｕｍ比。如果仍然是ｐ
０一 >ｎｕｍ大，则应使ｐｌ继续后移，直到ｐ０一 >
ｎｕｍ <=ｐ１一 >ｎｕｍ为止。这时将ｐ０所指的结
点插到ｐｌ所指结点之前。但是如果ｐ１所指的已是
表尾结点，则ｐｌ就不应后移了。如果ｐ０一 >ｎｕ
ｍ比所有结点的ｎｕｍ都大,
则应将ｐ０所指的结点插到链表末尾。
如果插入的位置既不在第一个结点之前，又不在
表尾结点之后，则将ｐ０的值赋给ｐ２一 >ｎｅｘｔ，
即使ｐ２一 >ｎｅｘｔ指向待插入的结点，然后将ｐ
ｌ的值赋给ｐ０ -＞ｎｅｘｔ，即使得ｐ０一 >ｎｅｘ
ｔ指向ｐｌ指向的变量。见图１０．２３（ c）。可
以看到，在第一个结点和第二个结点之间已插入了一
个新的结点。
如果插入位置为第一结点之前（即ｐｌ等于ｈｅａ
ｄ时）,
则将ｐ０赋给ｈｅａｄ，将ｐ１赋给ｐ 0->ｎｅｘｔ。
见图１０．２３（ d）。如果要插到表尾之后，应将
ｐ０赋给ｐｌ一 >ｎｅｘｔ，ＮＵＬＬ赋给ｐ０一 >ｎ
ｅｘｔ，见图１０．２３（ｅ）。
以上算法可用图１０．２４表示。
［例１ 1,１０］插入结点的函数ｉｎｓｅｒｔ如
下。
ｓｔｒｕｃｔ ｓｔｕｄｅｎｔ *ｉｎｓｅｒｔ
（ｈｅａｄ，ｓｔｕｄ）
ｓｔｒｕｃｔ ｓｔｕｄｅｎｔ ＊ｈｅａｄ，
*ｓｔｕｄ,
{ｓｔｒｕｃｔ ｓｔｕｄｅｎｔ ＊ｐ０,*ｐ１,*
ｐ２；
ｐｌ =ｈｅａｄ； /*使ｐｌ指向第一个结
点 *／
ｐ０＝ｓｔｕｄ；／ *p0指向要插入的结
点 *／
ｉｆ （ｈｅａｄ＝ =ＮＵＬＬ）／ *原来
是空表 *／
{ｈｅａｄ =ｐ０；ｐ０一 >ｎｅｘｔ =Ｎ
ＵＬＬ；｝／ *使ｐ０指向的结点作为第一个结点 *／
ｅｌｓｅ
｛ｗｈｉｌｅ （（ｐ０一 >ｎｕｍ＞ｐ
ｌ一 >ｎｕｍ） &&（ｐｌ一 >ｎｅｘｔ！＝ＮＵＬＬ））
{p２＝ p1； p1=ｐｌ一 >ｎｅｘ t； }／ *ｐ
２指向刚才ｐｌ指向的结点,p1后移一个结点 *／
ｉｆ（ｐ０ ->ｎｕｍ＜＝ｐｌ一）ｎｕｍ）
｛ｉｆ （ｈｅａｄ ==ｐｌ） ｈｅａ
ｄ＝ｐ０；／ *插到原来第一个结点之前 *／
ｅｌｓｅ ｐ２ ->ｎｅｘｔ =p0;／ *插到ｐ２指向的结点
之后 *／
ｐ０ —＞ nｅｘｔ =ｐ１； }
elｓｅ
｛ｐｌ一 >ｎｅｘｔ =ｐ０；ｐ０一 >ｎｅｘｔ =Ｎ
ＵＬＬ； }}／ *插到最后的结点 之后 *／
ｎ =ｎ＋１； ／ *结点数加１ *／
ｒｅｔｕｒｎ （ ｈｅａｄ ） ；
}
函数参数是ｈｅａｄ和ｓｔｕｄ,sｔｕｄ也是一个指针
变量，从实参传来待插入结点的地址给ｓｔｕｄ。语
句ｐ０ =ｓｔｕｄ的作用是使ｐ０指向待插入的结点。
函数类型是指针类型，函数值是链表起始地址ｈｅ
ａｄ。
将以上建立、输出、删除、插入的函数组织在一个
程序中，用ｍａｉｎ函数作主调函数。可以写出以下
ｍａｉｎ函数。
ｍａｉｎ（）
{ｓｔｒｕｃｔ ｓｔｕｄｅｎｔ *ｈｅａｄ,ｓｔｕ ;
１ｏｎｇ ｄｅ１ _ｎｕｍ；
ｐｒｉｎｔｆ（, ｉｎｐｕｔ ｒｅｃｏｒｄｓ：
＼ n"）；
ｈｅａｄ＝ｃｒｅａｔ（）； ／ *返回头指针 *
／
ｐｒｉｎｔ（ｈｅａｄ）； ／ *输出全部结点 *／
ｐｒｉｎｔｆ（, ＼ｎｉｎｐｕｔ ｔｈｅ ｄｅｌ
ｅｔｅｄ 0ｎｕｍｂｅｒ：, ）；
ｓｃａｎｆ（, ％ｌｄ,, &dｅ１ _ｍｕｍ）；／
*输入要删除的学号 *／
ｈｅａｄ＝ｄｅｌ（ｈｅａｄ，ｄｅ１ _ｎｕ
ｍ）；／ *删除后的头地址 *／
ｐｒｉｎｔ（ｈｅａｄ）； ／ *输出全部结点 *
／
ｐｒｉｎｉｆ（, /nｉｎｐｕｔ ｔｈｅ ｉｎｓｅｒ
ｔｅｄ ｒｅｃｏｒｄ,")／ *输入要插入的记录 *／
ｓｃａｎｆ（, ％ｌｄ，％ f"，＆ｓｔｕ,ｎｕｍ，
＆ｓｔｕ,ｓｃｏｒｅ）；
ｈｅａｄ =ｉｎｓｅｒｔ（ｈｅａｄ，＆ｓｔｕ）；
／ *返回地址 *／
ｐｒｉｎｔ（ｈｅａｄ）；
}
此程序运行结果是正确的。
它只删除一个结点，插入一个结点。但如果想再插入一
个结点，重复写上程序最后四行，即共插入两个结点。
运行结果却是错误的。
ｉｎｐｕｔ ｒｅｃｏｒｄｓ：（建立链表）
８９１０１，９０
８９１０３，９８
８９１０５，７６
０，０
Ｎｏｗ，Ｔｈｅｓｅ ３ ｒｅｃｏｒｄｓ ａｒｅ,
８９１０１ ９０．０
８９１０３ ９８．０
８９１０５ ７６．０
ｉｎｐｕ ｔｈｅ ｄｅｌｅｔｅｄ ｎｕｍ ber,
８９１０３ （删除）
ｄｅｌｅｔｅ,８９１０３
Ｎｏｗ，Ｔｈｅｓｅ ２ ｒｅｃ oｒｄｓ ａｒｅ,
８９１０１ ９ 0,0 ８９１０５ ７
６．０
ｉｎ pｕｔ ｔｈｅ ｉｎｓｅｒｔｅｄ ｒｅｃｏ
ｒｄ：８９１０２
９０ （ 插入第一个结点 ）
Ｎｏｗ, Ｔｈｅｓｅ ３ ｒｅｃｏｒｄｓ ａｒｅ,
８９１０１ ９０, ０
８９１０２ ９０, ０
８９１０５ ７６．０
ｉｎｐｕｔ ｔｈｅ ｉｎｓｅｒｔｅｄ ｒｅｃｏ
ｒｄ：８９１０４，９９／（插入第二个结点）
Ｎｏｗ，Ｔｈｅ ４ ｒｅｃｏｒｄｓ ａｒｅ,
８９１０１ ９０．０
８９１０４ ９９．０
８９ 1０４ ９９。０
８９１０４ ９９．０
,.,
,.,
（无终止地输出８９１０４的结点数据）
请读者将ｍａｉｎ与ｉｎｓｅｒｔ函数结合起来考
察为什么会产生以上运行结果。
出现以上结果的原因是：ｓｔｕ是一个有固定地址
的变量。第一次把ｓｔｕ结点插入到链表中。第二次
若再用它来插入第二个结点，就把第一次结点的数据
冲掉了。
实际上并没有开辟两个结点。读者可根据ｉｎｓｅｒｔ
函数画出此时链表的情况。为了解决这个问题，必须
在每插入一个结点时新开辟一个内存区。我们修改ｍ
ａｉｎ函数，使之能删除多个结点（直到输入要删的
学号为０），能插入多个结点（直到输入要插入的学
号为０）。
ｍａｉｎ函数如下,
ｍａｉｎ（）
｛ｓｔｒｕｃｔ ｓｔｕｄｅｎｔ *ｈｅａｄ，
*ｓｔｕ；
１ｏｎ g ｄｅ１ _ｎｕｍ；
ｐｒｉｎｔｆ（ "ｉｎｐｕｔ ｒｅｃｏｒｄｓ：
/n”）；
ｈｅａｄ＝ｃｒｅａｔ（）；
ｐｒｉｎｔ （ｈｅａｄ）；
ｐｒｉｎｔｆ（, /nｉｎｐｕｔ ｔｈｅ ｄｅｌ
ｅｔｅｄ ｎｕｍｂｅｒ,");
ｓｃａｎｆ（, ％ 1d”，＆ｄｅ l_ｎｕｍ）；
ｗｈｉｌｅ （ｄｅ１ _ｎｕｍ！＝０）
｛ｈｅａｄ =ｄｅｌ（ｈｅａｄ，ｄｅ l_ｎｕｍ） ;
ｐｒｉｎｔ（ｈｅａｄ） ;
ｐｒｉｎｔｆ（, ｉｎｐｕｔ ｔｈｅ ｄｅｌ
ｅｔｅｄ ｎｕｍｂｅｒ,");
ｓｃａｎｆ（, ％ ld"，＆ｄｅ l_ｎｕｍ）；
ｐｒｉｎｔｆ（, ＼ｎｉｎｐｕｔ ｔｈｅ ｉ
ｎｓｅｒｔｅｄ ｒｅｃｏｒｄ,");
ｓｔｕ＝（ｓｔｒｕｃｔ ｓｔｕｄｅｎｔ *）ｍａｌ
ｌｏｃ（ＬＥＮ） ;
ｓｃａｎｆ（, ％ 1d,％ f,”，＆ｓｔｕ一 >ｎｕｍ，
＆ｓｔｕ一 >ｓｃｏｒ );
ｗｈｉｌｅ （ｓｔｕ一 >ｎｕｍ！＝０）
｛ ｈｅａｄ＝ｉｎｓｅｒｔ （ ｈｅａｄ, ｓｔ
ｕ ）,
ｐｒｉｎｔ （ ｈｅａｄ ） ；
ｐｒｉｎｉｆ（ "ｉｎｐｕｔ ｔｈｅ ｉｎｓｅｒｔ
ｅｄ ｒｅｃｏｒｄ,");
ｓ tu=（ｓｔｒｕｃｔ ｓｔｕｄｅｎｔ *）ｍａ
ｌｌｏｃ（ＬＥＮ） ;
ｓ cａｎｆ（, ％ 1d，％ f,＆ｓｔｕ一 >ｎｕｍ，
＆ｓｔｕ一 >ｓｃｏｒｅ） ;
}
}
sum定义为指针变量，在需要插入时先用ｍａ llｏｃ函
数开辟一个内存区，将其起始地址经强制类型转换后
赋给 stｕ，然后输入此结构体变量中各成员的值。对
不同的插入对象,stu的值是不同的，每次指向一个
新的结构体变量。在调用 insert函数时，实参为ｈ ea
ｄ和 stu,将已建立的链表起始地址传给 insert函数的
形参，将 stu（既新开辟的单元的地址）传给形参
stud,函数值返回经过插入之后的链表的头指针（地
址）,
运行情况如下,
ｉｎｐｕｔ ｒｅｃｏｒｄｓ,
８９１０１，９９
８９１０３，８７
８９１０５，７７
０，０
Ｎｏｗ,Ｔｈｅｓｅ ３ ｒｅｃｏ rｄｓ
ａｒｅ。
８９１０１ ９９．０
８９１０３ ８７．０
８９１０５ ７７．０
inｐｕｔ ｔｈｅ ｄｅｌｅｔｅｄ ｎｕｍｂｅｒ：
８９１０３
ｄｅｌｅｔｅ：８ 9103
Ｎｏｗ，Ｔｈｅｓｅ ２ ｒｅｃｏｒｄｓ ａ
ｒｅ,
８９１０１ ９９．０
８９１０５ ７７．０
ｉｎｐｕｔ ｔｈｅ ｄｅ１ｅｔｅｄ ｎｕｍｂｅｒ：
８９１０５
ｄｅｌｅｔｅ：８９１０５
Ｎｏｗ，Ｔｈｅｓｅ ｌ ｒｅｃｏｒ ds ａｒ
ｅ,
８９１０１ ９９．０
ｉｎｐｕｔ ｔｈｅ ｄｅ１ｅｔｅｄ ｎｕｍｂｅ
ｒ：０
１ｎｐｕｔ ｔｈｅ ｉｎｓｅｒｔｅｄ ｒｅｃｏｒ
ｄ：８９１０４，８７
ＮＯｗ，Ｔｈｅｓｅ ２ ｒｅｃｏｒｄｓ ａｒ
ｅ,
８９１０１ ９９。０
８９１０４ 8７．０
ｉｎｐｕｔ ｔｈｅ ｉｎｓｅｒｔｅｄ ｒｅｃ
ｏｒｄ：８９１０６，６５
Ｎｏｗ,Ｔｈｅｓｅ ３ ｒｅｃｏｒｄｓ ａｒｅ,
８９１ 01 ９９, ０
８９１０４ ８７, ０
８９１０６ ６５, ０
ｉｎ pｕｔ ｔｈｅ ｉｎｓｅｒｔｅｄ ｒｅｃ
ｏｒｄ：０, ０
对这个程序请读者仔细消化 。
指针的应用领域很宽广, 除了单向链表之外, 还有
环形链表, 双向链表 。 此外还有队列, 树, 栈, 图等
数据结构 。
有关这些问题的算法可以学习, 数据结构 >>课程, 在此
不作详述 。
$１ 1．８ 共用体
１ 1．８,1 共用体的概念
有时需要使几种不同类型的变量存放到同一段内存
单元中。例如，可把一个整型变量、一个字符型变量、
一个实型变量放在同一个地址开始的内存单元中（见
图１０,２５）。以上三个变量在内存中占的字节数
不同，但都从同一地址开始（图中设地址为１０００）
存放。 1000
i
ch
f
也就是使用覆盖技术，几个变量互相覆盖。这种使几个
不同的变量共占同一段内存的结构,称为, 共用体,
类型的结构。
, 共用体, 类型变量的定义形式为,
union 共用体名
{ 成员表列 ;
} 变量表列；
例如,
ｕｎ ioｎ data
｛ iｎｔ i;
ｃｈ ar ｃｈ ;
floaｔ ｆ ;
｝ａ,b,ｃ ;
也可以将类型定义与变量定义分开,
ｕｎ ioｎ ｄａ ta
｛ｉｎｔ i;
ｃ hａｒ ｃ h;
floaｔ ｆ ;
};
union data a,b,c;
即先定义一个ｕｎｉｏｎ ｄａｔａ类型,
再将 a bｃ定义为 union ｄ ata类型。当然也可以直接
定义共用体变量，如,
union
{int i;
char f;
}a,b,c;
可以看到,,共用体, 与, 结构体, 的定义形式相
似。但它们的含义是不同的。
结构体变量所占内存长度是各成员占的内存长度之
和。每个成员分别占有其自己的内存单元。共用体变
量所占的内存长度等于最长的成员的长度。例如，上
面定义的, 共用体 "变量 a,b,c各占４个字节（因为一
个实型变量占４个字节），而不是各占２＋ 1＋４ =７
个字节。
目前国内有关Ｃ语言的书多把ｕｎｉＯｎ直译为“联
合”。作者认为，译为“共用体”
更能反映这种结构的特点, 即几个变量共用一个内存区 。
而, 联合, 这一名词；在一般意义上容易被理解为
,将两个或若干个变量联结在一起,, 难以表达这种
结构的特点 。 日本就是用, 共用体 "这一术语的 。
１ 1．８．２共用体变量的引用方式
只有先定义了共用体变量才能引用它。而且不能引
用共用体变量，而只能引用共用体变量中的成员。例
如，前面定义了 a,b,c为共用体变量，下面的引用方
式是正确的,
ａ,i（引用共用体变量中的整型变量 i）
ａ,ｃｈ（引用共用体变量中的字符变量ｃｈ）
ａ,f（引用共用体变量中的实型变量ｆ）
不能只引用共用体变量，例如,
ｐｒｉｎｔｆ（ " %d",a）
是错误的，ａ的存储区有好几种类型，分别占不同长度
的存储区，仅写共用体变量名 a,难以使系统确定究竟
输出的是哪一个成员的值。应该写成ｐｒｉｎｉｆ（,
％ d，ａ,i)或ｐｒｉｎｔｆ（, %c"，ａ,ｃｈ）等
１ 1．８,３共用体类型数据的特点
在使用共用体类型数据时要注意以下一些特点,
１．同一个内存段可以用来存放几种不同类型的成
员，但在每一瞬时只能存放其中一种，而不是同时存
放儿种。也就是说，每一瞬时只有一个成员起作用，
其它的成员不起作用，即不是同时都存在和起作用。
２．共用体变量中起作用的成员是最后一次存放的
成员，在存入一个新的成员后原有的成员就失去作用。
如有以下赋值语句）ａ,i=１；
ａ,ｃｈ ='a';
ａ,ｆ＝１．５ ;
在完成以上三个赋值运算以后，只有ａ,f是有效的，ａ,
ｉ和ａ,ｃ已经无意义了。此时用 printf（, ％ｄ,,
ａ,ｉ）是不行的，而用ｐ riｎ tｆ（, ％ f”,a.f）
是可以的，因为最后一次的赋值是向ａ,f赋值。因此
在引用共用体变量时应十分注意当前存放在共用体变
量中的究竟是哪个成员。
３．共用体变量的地址和它的各成员的地址都是同一地
址。例如,&a.&a.i&a.ch.&a.f都是同一地址值，其
原因是显然的。
４．不能对共用体变量名赋值，也不能企图引用变
量名来得到成员的值，又不能在定义共用体变量时对
它初始化。例如，下面这些都是不对的,
①ｕｎｉｏｎ
｛ｉｎｔ i；
ｃｈ aｒ ｃｈ ;
float ｆ ;
｝ａ＝ {1,?a?,1.5}; （不能初始化）
②ａ＝１； （不能对共用体变量赋值）
③ｍ＝ａ； （不能引用共用体变量名以得到值）
５．不能把共用体变量作为函数参数，也不能使函
数带回共用体变量，但可以使用指向共用体变量的指
针（与结构体变量这种用法相仿）。
６,共用体类型可以出现在结构体类型定义中，也可以
定义共用体数组。反之，结构体也可以出现在共用体
类型定义中，数组也可以作为共用体的成员。
「例１ 1,11］设有若干个人员的数据，其中有学生和
教师。学生的数据中包括：姓名,
号码, 性别, 职业, 班级 。 教师的数据包括：姓名, 号
码, 性别, 职业, 职务 。 可以看出, 学生和教师所包
含的数据是不同的 。 现要求把它们放在同一表格中,
见图１０, ２６ 。
如果, ｊ ob”项为, ｓ, （学生），则第５项为ｃｌａ
ss（班）。即Ｌｉ是５０ 1班的。如果, ｊ oｂ, 项是
,Ｔ, （教师），则第５项为 position（职务）。ｗ
ａｎ g是ｐ rｏ f（教授）。显然对第５项可以用共用
体来处理（将ｃ laｓｓ和ｐＯｓｉｔｉ０ｎ放在同一
段内存中）。
要求输入人员的数据，然后再输出。可以写出下面
的算法（见图１ 1．２７）。按此写出程序。为简化
起见。只设两个人（一个学生、一个教师）
/* example 11.11 */
#define N 2
struct
{ int num;
char name[10];
char sex;
char job;
union
{ int class;
char position[10];
} category;
} person[2];
main()
{ int n,i;
for(i=0;i<N;i++)
{
printf("Inupt the num name sex and job(s or t) \n");
scanf ("%d%s %c %c",
&person[i].num,person[i].name,&person[i].sex,&person[i]
.job);
if (person[i].job =='s')
{printf("input class num\n");
scanf ("%d",&person[i].category.class);}
else if (person[i].job =='t')
{printf("input position\n");
scanf("%s",person[i].category.position);}
else printf("input error!");
}
printf("\n");
printf("No,name sex job class/position\n");
for (i=0;i<N;i++)
{if (person[i].job=='s')
printf("%-6d%- 10s%-3c%-3c %-
10d\n",person[i].num,
person[i].name,person[i].sex,person[i].job,
person[i].category.class);
else printf("%-6d%-10s%-3c%-3c %-
10s\n",person[i].num,
person[i].name,person[i].sex,person[i].job,
person[i].category.position);
}
}
运行情况如下,
１０１ Ｌｉ ｆ ｓ ５０１
１０２ Ｗａｎｇ ｍ ｔ ｐｒｏｆｅｓｓｏｒ
Ｎｏ。 Ｎａｍｅ ｓｅｘ ｊｏｂ ｃｌａｓｓ
／ｐｏｓｉｔｉｏｎ
可以看到：在ｍａ in函数之前定义了外部的结构体数组
pｅｒｓｏｎ，在结构体类型定义中包括了共用体类
型，ｃａｔｅｇｏｒｙ（分类）是结构体中一个成员
名，在这个共体中一个成员为ｃｌａｓｓ和ｐｏｓｉ
ｔｉｏｎ，前者为整型，后者为字符数组（存放, 职
务, 的值 ——字符串）。
这种共用体变量的用法是很有用的 。 例如, 可以设
一个单元 data,内放一个常量, 此常量可以是整型,
实型或字符型, 双精度等 。
在程序中根据, 类型标志, 来决定按何种类型处理。
如,
ｓｔｒｕｃｔ
{..,
ｕｎ ion
｛ int I;
ｃｈａｒ ｃｈ ;
float f;
ｄｏｕｂｌｅ ｄ ;
｝ｄａｔａ；
ｉｎｔ ｔｙ pｅ；
）ａ；
ｓｗｉｔｃｈ（ａ,ｔｙｐｅ）
case 0,printf（, ％ｄ \n”，ａ,data.i）； break;
Case 1:printf（, ％ｃ \n"，ａ,data.ch）； break;
Case 2:printf（, ％ f\n”ａ,data.f）； break;
Case 3:printf（, ％ｆ \n”，ａ,data.ｄ）； break;
}
结构体中的ｔｙｐ e作为, 类型标志,,如果在共用体
成员中存放整数，则使ｔｙ pe=０；若存放字符，则
使ｔｙｐ e＝１；若存放实型，则使ｔｙｐ＝２；若
存放双精度型，使ｔｙｐ e=３。然后在ｓｗｉｔｃｈ
语句中根据ａ,type的值来决定按哪一种类型输出。
这在写系统软件时，用来处理符号表是有用的。在符
号表中可以包含符号名、类型和值。根据不同情况进
行不同处理。
１ 1．９ 枚举类型
枚举类型是 ANSI Ｃ新标准所增加的。
如果一个变量只有几种可能的值，可以定义为 枚举类型 。所
谓, 枚举, 是指将变量的值一一列举出来，变量的值只限于列
举出来的值的范围内。
定义枚举类型用 enum(enumerate)开头。例如
enum weekday {sun,mon,tue,wed,thu,fri,sat};
定义了一个枚举类型 enum weekday，可以用此类型来定义变量。
如
enum weekday workday,week_end;
workday和 week_end被定义为枚举变量，它们的值只能是 sun
到 sat之一。例如,
workday=mon;
week_end=sun;
是正确的。
当然，也可以直接定义枚举变量，如
enum weekday
{sun,mon,tue,wed,thu,fri,sat} workday,week_end ；
其中ｓｕｎ, ｍｏｎ, …,sat,等称为 枚举元素或枚举
常量 。 它们是用户定义的标识符 。 这些标识符并不自
动地代表什么含义 。 例如, 不因为写成ｓｕｎ, 就自
动代表, 星期天 ".不写ｓｕｎ而写成ｓｕｎｄａｙ也
可以 。 用什么标识符代表什么含义, 完全由程序员决
定, 并在程序中作相应处理 。
说明
１ ·在Ｃ编译中，对枚举元素按常量处理，故称枚
举常量。它们不是变量，不能对它们赋值。例如
ｓｕｎ =０；ｍｏｎ＝１ ;
是错误的。
２．枚举元素作为常量，它们是有值的,C语言编译按
定义时的顺序使它们的值为０，１，２,……。
在上面定义中,sun的值为０，ｍｏｎ的值为１，
sat为６。如果有赋值语句
ｗｏｒｋｄａｙ＝ｍｏｎ；
ｗｏｒｋｄａｙ变量的值为１。这个整数是可以输出的。
如
printf（, ％ d”，ｗｏｒｋｄａｙ）；
将输出整数１。
也可以改变枚举元素的值，在定义时由程序员指定，如
enum weekday {sun=7,mon=1,tue,wed,thu,fri,sat}
workday,week_end;定义 sun为 7,mon=1,以后顺序加 1，
sat为 6,
3.枚举值可以用来作判断比较。如
ｉｆ（ｗｏｒｋｄａｙ ==ｍｏｎ） …
ｉｆ（ｗｏｒｋｄａｙ＞ｓｕｎ） ···
枚举值的比较规则是：按其在定义时的顺序号比较。如
果定义时未人为指定，则第一个枚举元素的值认作０。
故ｍｏｎ大于ｓｕｎ，ｓａｔ＞ｆｒｉ。
４．一个整数不能直接赋给一个枚举变量。如
ｗｏｒｋｄａｙ＝２；
是不对的。它们属于不同的类型。应先进行强制类型转
换才能赋值。如
ｗｏｒｋｄａｙ＝（ｅｎｕｍ ｗｅｅｋｄａｙ）２；
它相当干将顺序号为２
的枚举元素赋给 workday，相当于
workday＝ tue；
甚至可以是表达式。如
workday＝（ enum weekday） (5-3)；
［例１ 1．１２ 】 口袋中有红、黄、蓝、白、黑五种
颜色的球若干个。每次从口袋中取出３个球，问得到
三种不同色的球的可能取法，打印出每种组合的三种
颜色。
球只能是５种色之一，而且要判断各球是否同色，应该
用枚举类型变量处理。
设取出的球为 I,j,k.根据题意,I,j,k分别是５种
色球之一，并要求 I!=j!=k.可以用穷举法，即一种可
能一种可能地试，看哪一组符合条件。
算法可用图１０。２８表示。
用ｎ累计得到三种不同色球的次数。外循环使第一个
球ｉ从ｒｅｄ变到ｂｌａｃｋ。中循环使第二个球ｊ
也从ｒｅｄ变到ｂｌａｃｋ。如果ｉ和ｊ同色则不可
取；
只有 I,j不同色 (I!=j)时才需要继续找第三个球，此时第三
个球ｋ也有５种可能（ｒｅｄ到ｂｌａｃｋ），但要
求第三个球不能与第一个球或第二个球同色，即
ｋ !=I,k!=j.满足此条件就得到三种不同色的球。输出
这种三色组合方案。然后使 n加１。外循环全部执行
完后，全部方案就已输
出完了 。 最后输出总数 n,
下面的问题是如何实现图１０, ２８中的, 输出一
种取法, 。 这里有一个问题,
如何输出, ｒｅｄ,,, ｂｌｕｅ,, ……等单词。不
能写成ｐｒｉｎｔｆ（ "％ s"，ｒｅｄ）来输出, ｒ
ｅｄ, 字符串。可以采用图１０．２９的方法。
为了输出３个球的颜色，显然应经过三次循环，第
一次输出ｉ的颜色，第二次输出ｊ的颜色，第三次输
出ｋ的颜色。在三次循环中先后将 I,j,ｋ赋予ｐｒｉ。
然后根据ｐｒｉ的值输出颜色信息。在第一次循环时，
ｐｒｉ的值为１，如果ｉ的值为ｒｅｄ，则输出字符
串, ｒｅｄ,,其它的类推。
程序如下,
ｍａｉｎ（）
{eｎｕｍ ｃｏｌｏｒ {ｒｅｄ，ｙｅｌｌｏｗ，
ｂｌｕｅ，ｗｈｉｔｅ，ｂｌａｃｋ };
enum color ｉ，ｊ，ｋ，ｐｒｉ ;
int n,loop;
n=0;
for (I=red;I<=black;I++)
for (j=red;j<=balack;j++)
if (I!=j)
{for (k=red;k<=black,k++)
if ((k!=I)&&(k!=j))
{n=n+1;
printf("%-4d",n);
for (loop=1;loop<=3;loop++)
{switch(loop)
{case 1:pri=i;break;
case 2:pri=j;break;
case 3:pri=k;break;
default:break;
}
switch(pri)
{casered:printf("%-10s,"red");break;
case yellow:printf("%-
10s","yellow");break;
case blue:printf("%-
10s","blue");break;
case white:printf("%-
10s","white");break;
case black:printf("%-
10s","black");break;
default:break;
}
}
printf("\n");
}
}
printf("\ntoal:%5d\n",n);
}
运行结果如下,
1 red yellow blue
2 red yellow white
3 red yellow black
4 red blue yellow
5 red blue white
6 red blue black
7 red white yellow
8 red white blue
9 red white black
10 red black yellow
。。。。。。。。。。。。。。。。。
６０ black white blue
ｔｏｔａ１：６０
有人说，不用枚举变量而用常数０表, 红,, 1表
,黄 ………,不也可以吗？是的，完全可以。但显然用
枚举变量更直观，因为枚举元素都选用了令人, 见名
知意, 标识符，而且枚举变量的值限制在定义时规定
的几个枚举元素范围内，如果赋予它一个其它的值，
就会出现出错信息，便于检查。
$11.10 用 typdef定义类型
除了可以直接使用Ｃ提供的标准类型名（如
int.char,float.double.long等）和自己定义的结
构体、共用体、指针、枚举类型外还可以用 typedef
定义新的类型名来代替已有的类型名如,
typedef int INTEGER;
typedef float REAL;
指定用 INTEGER 代表 int类型,REAL代表 float,这样，
以下两行等价,
① int i,j;； float ａ,b;
② INTEGER i,j; REAL ａ,b;
这样可以使熟悉Ｆ０ＲＴＲＡＮ的人能用 INTEGER 和
REALL定义变量，以适应他们的习惯。
如果在一个程序中，一个整型变量用来计数，可以,
Typedef int COUNT;
COUNT i,j;
即将变量 i.j定义为 COUNT类型，而 COUNT等价于 int，因此 i、ｊ是
整型。但在程序中将 i,j定为 COUNT类型，可以使人更一目了然
地知道它们是用于计数的。
可以定义结构体类型,
ｔｙｐｅｄｅｆ ｓｔｒｕｃｔ
｛ｉｎｔ ｍｏｎｔ；
ｉｎｔ ｄａｙ；
iｎｔ ｙｅａｒ；
｝ DATE;
定义新类型名 DATE，它代表上面定义的一个结构体类型。这时就
可以用 DATE定义变量,
DATE birthday；（不要写成 struct DATA birthday;）
DATA *ｐ ; (p为指向此结构体类型数据的指针）
还可以进一步,
１ typedef NUM［ 1００］；（定义 NUM为整型数
组类型）
NUM n; （定义ｎ为整型数组变量）
２,typedef char *STRING； （ 定义 STRING为字符指
针类型 ）
STRING ｐ, s[１０ ]； （ p为字符指变量, s为指针
数组 ）
３, typed int (*POINTER)() （ 定义 POINTER
为指向函数的指针类型, 该函数返回整型值 ）
POINTER p1,p2； (p1,p2为 POINTER 类型的指针变量 ）
归纳起来, 定义一个新的类型名的方法是,
① 先按定义变量的方法写出定义体（如,int i；）。
②将变量名换成新类型名（如：将ｉ换成 COUNT）。
③在最前面加 typedef（如,typedef int COUNT）。
④然后可以用新类型名去定义变量。
再以定义上述的数组类型为例来说明,
①先按定义数组变量形式书写,int n[100];
② 将变量名ｎ换成自己指定的类型名,int NUM[100]
③ 在前面加上 typedef，得到 typedef int NUM[100];
④ 用来定义变量,NUM ｎ,
同样，对字符指针类型，也是：①ｃｈａｒ *p;
② ｃｈａｒ * STRING；③ typedef *STRING；
④ STRING ｐ，ｓ［１０］；
习惯上常把用 typedef定义的类型名用大写字母表
示，以便与系统提供的标准类型标识符相区别。
说明,
１．用 typｅｄｅｆ可以定义各种类型名，但不能
用来定义变量。用 typedf可以定义出数组类型、字符
串类型，使用比较方便。如定义数组，原来是用
ｉｎｔ ａ [１０］,b[１０ ],c[1０,d[１０ ];
由于都是一维数组，大小也相同，可以先将此数组类型
定为一个名字,
ｔｙ pｅｄｅｆ ｉｎｔ ＡＲＲ [1０］；
然后用ＡＲＲ去定义数组变量,
ＡＲＲａ,b，ｃ，ｄ；
ＡＲＲ为数组类型，它包含１０个元素。因此，
ａ,b,ｃ,ｄ都被定义为一维数组，含１０个元素。
可以看到，用 typｅｄｅｆ可以将数组类型和数组
变量分离开来，利用数组类型可以定义多个数组变量。
同样可以定义字符串类型、指针类型等。
２．用 typｅｄｅｆ只是对已经存在的类型增加一
个类型名，而没有创造新的类型。
例如，前面定义的整型类型 COUＮＴ，它无非是对ｉｎ
ｔ型另给一个新名字。又如
ｔｙｐｅｄｅｆ ｉｎｔ ＮＵＭ［１０］；
无非是把原来用 "int n[１０ ]； "定义的数组变量的类
型用一个新的名字ＮＵＭ表示出来。无论用哪种方式
定义变量，效果都是一样的。
３,tｙｐｅｄｅｆ与＃ｄｅｆｉｎｅ有相似之处，
如
ｔｙｐｄ ef int CＯＵＮＴ；
和 ＃ｄｅｆｉｎｅ ＣＯＵＮＴ ｉｎ t
的作用都是用 COＵＮＴ代表ｉｎｔ。但事实上，它们二
者是不同的。＃ｄｅｆｉｎｅ是在预编译时处理的，
它只能作简单的字符串替换，而ｔｙｐｅｄｅｆ是在
编译时处理的。实际上它并不是作简单的字符串替换，
例如
ｔｙｐｅｄｅｆ ｉｎｔ ＮＵＭ [１０ ]
并不是用ＮＵＭ [１０］去代替ｉｎｔ，而是采用如同
定义变量的方法那样来定义一个类型
（就是前面介绍过的将原来的变量名换成类型名 ),
４．当不同源文件中用到同一类型数据（尤其是像数
组、指针、结构体、共用体等类型数据）时，常用ｔ
ｙ Pｅｄｅｆ定义一些数据类型，把它们单独放在一
个文件中，然后在需要用到它们的文件中用＃ｉｎｃ
ｌｕｄｅ命令把它们包含进来。
５, 使用ｔｙ Pｅｄｅｆ有利于程序的通用与移植 。
有时程序会依赖于硬件特性, 用ｔｙｐｅｄｅｆ便于
移植 。 例如,
有的计算机系统１ｎｔ型数据用两个字节，数值范围为
一３２７６８～３２７６７，而另外一些机器则以４
个字节存放一个整数，数值范围为 + -２１亿。如果
把一个Ｃ程序从一个以４个字节存放整数的计算机系
统移植到以２个字节存放整数的系统，按一般办法需
要将定义变量中的每个 iｎｔ改为１ｏｎｇ。例如，
将, iｎｔ ａ,b,c;”，如果程序中有多处用ｉｎ
ｔ定义变量，则要改动多处。现可以用一个ｔｙｐｅ
ｄｅｆ定义,
ｔｙｐ eｄ ef ｉｎｔ ＩＮＴＥＧ EＲ ;
在程序中用ＩＮＴＥＧＥＲ定义变量。在移植时只需改
动 typｅｄｅｆ定义体即可,
ｔｙｐ eｄ ef long ＩＮＴＥＧＥＲ ;
11.1 概 述
数据的基本类型：整型、实型、字符型等
构造类型：数组
如何描述一个学生的基本信息?
学号, 名称, 性别, 年龄, 成绩, 地址
C语言提供了这样一种数据结构,结构体 （ structure)
它相当于, 记录, 。
num name sex age score addr
10010 LiFun M 18 87.5 Beijing
例如, struct student
｛ int num;
char name[20]；
char sex;
int age；
float score；
char addr[30]；
};
定义一个结构体类型的一般形式为,
struct 结构体名
{
成员表列
}；
, 成员表列, 对各成员都应进行类型说明，即,
类型标识符 成员名；
也可以把, 成员表列, 称为, 域表,,每一个成员
称为结构体中的一个域。
１ 1.2 定义结构体类型变量的方法
要定义一个结构体类型的变量, 可以采取以
下三种方法 。
一, 先定义 结构体类型 再定义 变量名
如已定义 结构体类型 struct student,可以
用它来定义变量,
struct student student1,student2；
为了使用方便，人们通常用一个符号常量代表一个结构
体类型。在程序开头，用
＃ define STUD struct student -预处理命令
在程序中,STUD与 struct student完全等效 。
STUD
｛ int num;
char name[20]；
char sex;
int age；
float score；
char addr[30]；
};
可以直接用 STUD定义变量,
STUD student1,student2；
二、在定义类型的同时定义变量
例如,struct student
｛ int num;
char name[20];
char sex;
int age;
float score;
char addr[30];
} student1,student2；
既定义了类型，又定义了两个 struct student类型的
变量 student1,student2。
三、直接定义结构类型变量
其一般形式为,
struct --无结构体名
{
成员表列
}
变量名表列；
关于结构体类型，有几点要说明,
１．类型与变量是不同的概念,
只能对变量赋值、存取或运算，而不能对类型赋值、
存取或运算。
在编译时，对类型是不分配空间的，只对变量分
配空间。
2,对结构体中的成员（即, 域, ），可以单独使用，
它的作用与地位相当于普通变量；
strcpy(student1.name,”zhang”)
3,成员名可以与程序中的变量名相同；
4．成员也可以是一个结构体变量。
如,struct date
｛ int month;
int day;
int year; };
struct student
{ int num;
char name［２０ ];
char sex;
int age;
struct date birthday；
char addr[３０ ];
｝ student1,student2；
说明：先定义一个结构体ｄａ tｅ类型，它代表, 日
期,,包括三个成员。
１ 1.３ 结构体类型变量的引用
引用方式,结构体变量名,成员名
student.num=10010；
注：, ·”是成员（分量）运算符，它在所有的运算
符中优先级最高。
引用结构体变量应遵守以下规则,
１, 不能将一个结构体变量作为一个整体进行
输入和输出 。
printf(”%d,%s,%c,%d,%f,%s\n,”,student1)；
只能对结构体变量中的各个成员分别输出。
２ ·如果成员本身又属一个结构体类型，则要用
若干个成员运算符，一级一级地找到最低的
一级的成员。只能对最低级的成员进行赋值
或存取以及运算。
student1.num
student1.name
student1.birthday.month
Student1.birthday.day
Student1.birthday.year
注意,不能用 student1.birthday 来访问 student1变
量中的成员 birthday，因为 birthday本身是一个结
构体变量。
３．对成员变量可以像普通变量一样进行各种
运算（根据其类型决定可以进行的运算）。
例如,
student2.score=student1.score；
sum=student1.score+student2.score；
student1.age++；
++student1.age；
４．可以引用成员的地址，也可以引用结构体
变量的地址。
例如,
scanf（ "％ d”,&student1.num）；
（输入 student1.num的值）
printf（, %o”,&student1）；
（输出 student1的首地址）
11．４ 结构体变量的初始化
例如,
Struct student
｛ long int num；
char name[20]；
char sex；
char addr［ 20]；
}ａ＝ {20034101,,Lilin”,?M?,“WS Road”};
在定义时赋初值。
例 1 p264_b1
１ 1.５ 结构体数组
定义,数组中的每一个元素是结构体, 则该
数组是结构体数组 。
例如,
struct student
｛ int num；
char name[20]；
char sex；
int age；
float score；
char addr[30]；
}；
struct student stu[3]；
二、结构体数组的初始化
如,struct student
{ int num；
char name[20]；
char sex；
int age；
float score；
char add[30]；
｝
Stu[3]={{1,“ZHANG,,?Ｍ ’,18,87.5,“WS
Road"},{…},{…}}；
三、举例
p266_b2
１ 1.６ 指向结构体类型数据的指针
一个结构体变量的指针就是该变量所占据的内存段的起始地址 。
11.6.1 指向结构体变量的指针
例 3 ＃ include,string.h"
main()
{ struct student
{long int num;
char name[２０ ]；
char sex;
float score； };
struct student stu_1,*p;
ｐ =&stu_1;
stu_1.num=89101
strcpy(stu_1.name,” Ｌｉ lｉｎ, ）；
stu_1.sex=?Ｍ ’ ；
stu_1.score＝８９,5；
printf(”No:％ ld＼ nname:％ s\nsex:％ c\ｎ score:％
f\n”,stu_1.num,stu_1.name,stu_1.sex，
stu_1.score） ;
printf("\nNo.:%1d\nname:%s\nsex:%c\nscore:%f\n",
(*p).num,(*p).name,(*.p).sex,(*p).score);
} p 89101
“Lilin”
?M?
89.5
说明,
（ *p）表示ｐ指向的结构体变量,
(*p).num 是ｐ指向的结构体变量中的成员 num。
*p.num 表示？
在Ｃ语言中，可以把 (*p).num用 ｐ ->ｎｕｍ 来代替，
表示ｐ所指向的结构体变量中的ｎｕｍ成员 。
①结构体变量,成员名；
② (*ｐ ).成员名；
③ｐ ->成员名
ｐ ->ｎ＋＋ 得到ｐ指向的结构体变量中的成员ｎ的
值, 用完该值后使它加１ 。
＋＋ｐ ->ｎ 得到ｐ指向的结构体变量中的成员ｎ的
值使之加１ （ 先加 ） 。
11,6．２指向结构体数组的指针
［例 11.４］
struct student
{ int num;
char name[２０］；
char sex;
int age； }；
struct student stu［３］ ={
{{10101,” Ｌｉ Ｌｉｎ,, ‘ Ｍ ’,１８｝,
{101０ 2,” Ｚｈａｎｇ Ｆｕｎ,, ’ Ｍ ‘,19},
{10104,"wang Min",?F?,20}};
main()
{ struct student *p；
printf(”No,Name sex age\n”）；
for（ｐ =stu； p＜ stu+３；ｐ ++）
printf（, %5d%-20s%2c%4d\n”,
p->num,p->name,p->sex,p->age）；
}
１ 1.６,３用指向结构体的指针作函数参数
如何传递一个结构体变量的值给函数?
方法一,用结构体变量的成员作参数。
方法二,用结构体变量作实参。
方法三,用指向结构体变量的指针作实参。
例 5
１ 1．７ 用指针处理链表
１ 1．７,1链表概述
链表是一种常见的重要的数据结构。它是动态地进
行存储分配的一种结构。我们知道，用数组存放数据
时,
必须事先定义固定的长度 （ 即元素个数 ） 。 比如, 有的
班级有１００人, 而有的班只有３０人, 如果要用同
一个数组先后存放不同班级的学生数据, 则必须定义
长度为 100的数组 。 如果事先难以确定一个班的最多
人数, 则必须把数组定得足够大, 以能存放任何班级
的学生数据 。 显然这将会浪费内存 。 链表则没有这种
缺点, 它根据需要开辟内存单元 。 图１０, １１表示
最简单的一种链表 （ 单向链表 ） 的结构 。 链表有一个
,头指针, 变量, 图中以ｈｅａｄ表示, 它存放一个
地址 。
该地址指向一个元素。链表中每一个元素称为, 结点,,
每个结点都应包括两个部分：一为用户需要用的实际
数据，二为下一个结点的地址。课以看出,head指向
第一个元素；第一个元素又指向第二个元素； ……，
直到最后一个元素，该元素不再指向其它元素，它称
为 ‘ 表尾,,它的地址部分放一个, ＮＵＬＬ, （表
示, 空地址, ）。链表到此结束。
可以看到：链表中各元素在内存中可以不是连续存
放的。要找某一元素，必须先找到上一个元素，根据
它提供的下一元素地址才能找到下一个元素。
如果不提供, 头指针, （ head），则整个链表都无法访
问。链表如同一条铁链一样，一环扣一环，中间是不
能断开的。打个通俗的比方：幼儿园的老师带领孩子
出来散步，老师牵着第一个小孩的手，第一个小孩的
另一只手牵着第二个孩子,……，这就是一个, 链,,
最后一个孩子有一只手空着，他是, 链尾, 。要找这
个队伍，必须先找到老师，然后顺序找到每一个孩子。
可以看到，这种链表的数据结构，必须利用指针变
量才能实现
。即：一个结点中应包含一个指针变量，用它存放下一
结点的地址。
前面介绍了结构体变量, 它包含若干成员 。 这些成
员可以是数值类型, 字符类型, 数组类型, 也可以是
指针类型 。 这个指针类型可以是指向其它结构体类型
数据, 也可以指向它所在的结构体类型 。 例如,
sｔｒｕｃｔ sｔｕｄｅｎｔ
｛ ｉｎｔ ｎｕｍ ;
ｆｌｏａｔ ｓ coｒｅ ;
ｓｔｒｕｃｔ ｓｔｕｄｅｎｔ *ｎｅｘｔ ;
ｎｅ xt是成员名，它是指针类型的，它指向ｓｔｒ
ｕｃｔ ｓｔｕｄｅｎｔ类型数据（这就是ｎｅｘｔ
所在的结构体类型）。用这种方法可以建立链表。见
图１０．１２。
其中每一个结点都属于ｓ tｒｕｃ t ｓｔｕｄｅｎ
t类型，它的成员ｎｅｘ t存放下一结点的地址，程序
设计人员可以不必具体知道地址值,
只要保证将下一个结点的地址放到前一结点的成员ｎｅ
xt中即可。
请注意：上面只是定义了一个ｓｔｒｕｃｔ ｓｔ
ｕｄｅｎｔ类型，并未实际分配存储空间。前面讲过，
链表结构是动态地分配存储的，即在需要时才开辟一
个结点的存储单元。怎样动态地开辟和释放存储单元
呢？Ｃ语言编译系统的库函数提供了以下有关函数。
１,ｍａｌｌｏｃ（ｓｉｚｅ） 在内存的动态存
储区中分配一个长度为ｓｉｚｅ的连续空间。
此函数的值（即, 返回值 "）是一个指针，它的值是该
分配域的起始地址。如果此函数未能成功地执行，则
返回值为０。
２,calloc(n,size) 在内存的动态区存储中分配ｎ
个长度为ｓｉｚｅ的连续空间。函数返回分配域的起
始地址；如果分配不成功，返回０。
３,free(ptr) 释放由ｐｔｒ指向的内存区。ｐｔ
ｒ是最近一次调用ｃａ１１或ｍａ１１ｏｃ函数时返
回的值。
上面三个函数中，参数ｎ和ｓｉｚｅ为整型，ｐｔ
ｒ为字符型指针。
请注意：许多Ｃ版本提供的 malloｃ和 call０ｃ函数得
到的是指向字符型数据的指针。新标准Ｃ提供的ｍａ
１１０ｃ和ｃａ１１ oc函数规定为ｖｏｉｄ *类型。
有了本节所介绍的初步知识，下面就可以对链表进
行操作了（包括建立链表、插入或删除链表中一个结
点等）。有些概念需要在后面的应用中逐步建立和掌
握。
１ 1．７．２建立链表
所谓建立链表是指从无到有地建立起一个链表，即一个
一个地输入各结点数据，并建立起前后相链的关系。
下面通过一个例子来说明如何建立一个链表。
［例１ 1．７］写一函数建立一个有５名学生数据
的单向链表。
先考虑实现此要求的算法（见图１０,１３）。
设三个指针变量：ｈ eａｄ、ｐ１、ｐ２，它们都
指向结构体类型数据。先用ｍａｌ１ｏｃ函数开辟一
个结点，并使ｐ１、ｐ２指向它。
然后从键盘读人一个学生的数据给ｐｌ所指的结点。我
们约定学号不会为零，如果输入的学号为０，则表示
建立链表的过程完成，该结点不应连接到链表中。先
使ｈｅａｄ的值为ＮＵ LL（即等于０），这是链表为
,空, 时的情况（即ｈｅａｄ不指向任何结点，链表
中无结点），以后增加一个结点就使ｈｅａｄ指向该
结点。
如果输入的ｐｌ一 >ｎｕｍ不等于０，而且输入的是
第一个结点数据（ｎ =１）时，则令ｈｅａｄ＝ｐ１,
即把ｐ 1的值赋给ｈｅａｄ，也就是使ｈｅａｄ也指向
新开辟的结点（图１０．１４）。 P1所指向的新开
辟的结点就成为链表中第一个结点。然后再开辟另一
个结点并使ｐ１指向它，接着读入该结点的数据（见
图１０．１５（ａ））。如果输入的 p1->ｎｕｍ !=０，
则应链入第２个结点（ｎ＝２），由于ｎ !=１，则将
p1的值赋给 p2-->next,也就是使第一个结点的ｎｅｘ t
成员指向第二个结点（见图１０．１５（ b））。接
着使 p2=ｐ１,
也就是使ｐ２指向刚才建立的结点，见图１０．１５
（ｃ）。再开辟一个结点并使ｐｌ指向它，并读入该
结点的数据（见图１０．１６（ａ）），在第三次循
环中，由于ｎ＝３（ｎ !=１），又将ｐｌ的值赋给ｐ
２一 >next，也就是将第３个结点连接到第２个结点
之后，并使ｐ２ =ｐ１，使ｐ２指向最后一个结点
（见图１ 1.１６（ b）。
再开辟一个新结点，并使ｐｌ指向它,
输入该结点的数据（见图１ 1．１７（ａ））。由于ｐ
ｌ一 >ｎｕｍ的值为０，不再执行循环，此新结点不
应被连接到链表中。此时将ＮＵＬＬ赋给ｐ２一 >ｎ
ｅｘｔ，见图１０．１７（ b)。建立链表过程至此结
束，ｐｌ最后所指的结点未链入链表中，第３个结点
的ｎｅｘｔ成员的值为ＮＵＬＬ，它不指向任何结点。
虽然ｐｌ指向新开辟的结点，但从链表中无法找到该
结点。
建立链表的函数可以如下,
＃ｄ efine ＮＵＬＬ ０
＃ｄｅｆｉｎｅ ＬＥＮ ｓｉｚｅｏ f(ｓｔｒｕｃｔ
ｓｔｕ dent）
ｓｔｒｕｃｔ ｓｔｕｄ eｎｔ
｛１ｏｎ g ｎｕｍ ;
ｆ lｏａｔ ｓｃｏｒｅ；
sｔｒｕｃｔ sｔｕｄｅｎｔ *ｎｅ xｔ ;
};
ｉｎｔ ｎ ;
ｓｔｒｕｃｔ ｓｔｕｄｅｎｔ *ｃｒｅａｔ（）
／ *此函数带回一个指向链表头的指针 *／
｛ｓｔｒｕｃｔ ｓｔｕｄｅｎｔ *ｈｅａｄ；
ｓｔｒｕｃｔ ｓｔｕｄｅｎｔ ＊ p1,*ｐ２；
ｎ＝０ ;
p1=p2=（ｓｔｒｕｃｔ ｓｔｕｄｅｎｔ *）ｍａ
ｌ１ｏｃ（ＬＥＮ）；／ *开辟一个新单元 *／
ｓｃａｎｆ（ "％ ld，％ f"，＆ pl一 >ｎｕｍ，＆ p
ｌ一 >ｓｃｏｒｅ）；
ｈｅａｄ＝ＮＵＬＬ,
ｗｈｉｌｅ （ｐｌ一 >ｎｕｍ！＝０）
｛ｎ =ｎ十１；
ｉｆ（ｎ＝＝１） ｈｅａｄ＝ｐｌ；
ｅｌｓｅ ｐ２一 >ｎｅｘｔ＝ｐ１；
ｐ２ =ｐｌ；
ｐｌ＝（ｓｔｒｕｃｔ ｓｔｕｄｅｎｔ *）
ｍａｌｌｏｃ（ＬＥＮ）；
ｓｃａｎｆ（ "%1d，％ f"，＆ p1-->ｎｕｍ，＆ｐｌ一 >
ｓｃｏｒｅ）；
}
ｐ２一 >ｎｅｘｔ＝ＮＵ LＬ；
ｒｅｔｕｒｎ（ｈｅａｄ） ;
}
请注意,
（１）第一行为 #ｄｅｆｉｎｅ命令行，令ＮＵＬ
Ｌ代表０，用它表示, 空地址, 。第二行令ＬＥＮ代
表ｓｔｒｕｃｔ ｓｔｕｄｅｎｔ结构体类型数据的
长度,
ｓｉｚｅｏｆ是, 求字节数运算符, 。
（２）第９行定义一个ｃｒｅａｔ函数，它是指针
类型，即此函数带回一个指针值，它指向一个ｓｔｒ
ｕｃｔ ｓｔ uｄｅｎｔ类型数据。实际上此ｃｒｅ
ａｔ函数带回一个链（３）ｍａｌｌｏｃ（ＬＥＮ）
的作用是开辟一个长度为ＬＥＮ的内存区，ＬＥＮ已
定义为ｓｉｚｅｏｆ（ｓｔｒｕｃｔ ｓｔｕｄｅｎ
ｔ），即结构体ｓｔｒｕｃｔ ｓｔｕｄｅｎｔ的长
度。在一般系统中，ｍａｌｌｏｃ带回的是指向字符
型数据的指针。
而ｐ１、ｐ２是指向ｓｔｒｕｃｔ ｓｔｕｄｅｎｔ类
型数据的指针变量，二者所指的是不同类型的数据，
这是不行的。因此必须用强制类型转换的方法使之类
型一致，在ｍａｌｌｏｃ （ＬＥＮ）之前加了
,（ｓｔｒｕｃｔ ｓｔｕｄｅｎｔ *）,,它的作
用是使ｍａｌｌｏｃ返回的指针转换为指向ｓｔｒｕ
ｃｔ ｓｔｕｄｅｎｔ类型数据的指针。注意, *”
号不可省略，否则变成转换成ｓｔｒｕｃｔ ｓｔｕ
ｄｅｎｔ类型了，而不是指针类型了。
（４）最后一行ｒｅｔｕｒｎ后面的参数是ｈｅａｄ
（ｈｅａｄ已定义为指针变量，指向 strｕｃｔ ｓ
ｔｕｄｅｎｔ类型数据）。因此函数返回的是ｈｅａ
ｄ的值，也就是链表的头地址。
（５）ｎ是结点个数。
（６）这个算法的思路是：让ｐｌ指向新开的结点，
ｐ２指向链表中最后一个结点，把ｐｌ所指的结点连
接在 p2所指的结点后面，用, ｐ２一 >ｎｅｘｔ =ｐｌ,
来实现。
我们对建立链表过程作了比较详细的介绍,
读者如果对建立链表的过程比较清楚的话，对下面介绍
的删除和插入过程也就比较容易理解了。
１ 1．７．３输出链麦
将链表中各结点的数据依次输出。这个问题比较容
易处理。首先要知道链表头元素的地址，也就是要知
道ｈｅａｄ的值。然后设一个指针变量 p,先指向第一
个结点，输出ｐ所指的结点，然后使ｐ后移一个结点，
再输出。直到链表的尾结点。
「例１０．８］写出输出链表的函数ｐｒｉｎｔ。
ｖｏｉｄ ｐｒｉｎｔ（ｈｅａｄ）
ｓｔｒｕｃｔ ｓｔｕｄｅｎｔ *ｈｅａｄ ;
｛ｓｔｒｕｃｔ ｓｔｕｄｅｎｔ *ｐ；
ｐｒｉｎｔｆ（, \nNｏｗ，Ｔｈｅｓｅ％ｄ
ｒｅｃｏｒｄｓ aｒｅ：＼ n",n);
ｐ＝ｈｅａｄ；
if（ｈｅａｄ！＝ＮＵＬＬ）
ｄ o
｛ｐｒｉｎｔｆ（ "％ｌｄ％５,１ｆ＼ "，ｐ一 >ｎｕｍ，
ｐ —＞ｓｃｏｒｅ）；
ｐ =ｐ一 >ｎｅｘｔ；
｝ｗｈｉｌｅ（ｐ！ =ＮＵＬＬ）；
算法可用图１ 1．１８表示。
其过程可用图１ 1.１９表示。ｐ先指向第一结点，
在输出完第一个结点之后，ｐ移到图中ｐ '虚线位置，
指向第二个结点。程序中ｐ =ｐ一 >ｎｅｘｔ的作用是：
将ｐ原来所指向的结点中ｎｅｘｔ的值赋给ｐ,
而 p一 >ｎｅｘｔ的值就是第二个结点的起始地址。将它
赋给 p就是使ｐ指向第二个结点。
ｈｅａｄ的值由实参传过来，也就是将已有的链表
的头指针传给被调用的函数，在ｐｒｉｎｔ函数中从
ｈｅａｄ所指的第一个结点出发顺序输出各个结点。
１ 1．７．４ 对链麦的删除操作
已有一个链表，希望删除其中某个结点。怎样考虑
此问题的算法呢，先打个比方,
一队小孩 (Ａ,B.C.D.E）手拉手，如果某一小孩（Ｃ）
想离队有事，而队形仍保持不变。只要将Ｃ的手从两
边脱开，Ｂ改为与 D拉手即可，见图１０,２０。图１
０．２０（ａ）是原来的队伍，图１０,２０（ b)是
ｃ离队后的队伍。
与此相仿, 从一个链表中删去一个结点, 并不是真正
从内存中把它抹掉, 而是把它从链表中分离开来, 即
改变链接关系即可 。
［ 例１ 1,９ ］ 写一函数以删除指定的结点 。
我们以指定的学号作为删除结点的标志。例如，输入８
９１０３表示要求删除学号为８９１０３的结点。解
题的思路是这样的：从ｐ指向的第一个结点开始，检
查该结点中的ｎｕｍ值是否等于输入的要求删除的那
个学号。如果相等就将该结点删除，如不相等，就将
可以设两个指针变量ｐｌ和ｐ２，先使ｐｌ指向
第一个结点（图１０．２ 1（ａ））。如果要删除的
不是第一个结点,
则使ｐｌ后指向下一个结点（将ｐｌ一 >ｎｅｘｔ赋给
ｐｌ），在此之前应将ｐｌ的值赋给ｐ２，使ｐ２指
向刚才检查过的那个结点，见图１０。２１（ b）,如
此一次一次地使ｐ后移，直到找到所要删除的结点或
检查完全部链表都找不到要删除的结点为止。如果找
到某一结点是要删除的结点，还要区分两种情况：①
要删的是第一个结点（ｐｌ的值等于ｈｅａｄ的值，
如图１０,２１（ａ）那样），则应将ｐｌ一 >ｎｅｘ
ｔ赋给ｈｅａｄ。见图１０．２１（ｃ）。
这时 hｅ ad指向原来第二个结点。第一个结点虽然仍存
在，但它已与链表脱离，因为链表中没有一个元素或
头指针指向它。虽然ｐ１还指向它，它仍指向第二个
结点，但仍无济于事，现在链表的第一个结点是原来
第二个结点，原来第一个结点, 丢失, 。②如果要删
除的不是第一个结点，则将ｐｌ一 >ｎｅｘｔ赋给ｐ
２一 >ｎｅｘｔ，见图１０．２１（ d）,ｐ２一 >ｎｅ
ｘｔ原来指向ｐｌ指向的结点（图中第二个结点），
现在ｐ２一 >ｎｅｘｔ改为指向ｐ１一 >ｎｅｘｔ所指
向的结点
（图中第三个结点）。ｐｌ所指向的结点不再是链表的
一部分。
还需要考虑链表是空表（无结点）和链表中找不到
要删除的结点的情况。
图 11。 22表示解此题的算法,
删除结点的函数ｄｅｌ如下,
ｓｔｒｕｃｔ ｓｔｕｄｅｎｔ *ｄｅｌ（ｈｅ
ａｄ，ｎｕｍ）
ｓｔｒｕｃｔ ｓｔｕｄｅｎ t *ｈｅａｄ；
１ｏｎｇ ｎｕｍ；
｛ｓｔｒｕｃｔ ｓ tudent *p1,*p2;
if（ｈｅａｄ =＝ＮＵＬＬ） {ｐｒｉｎｔｆ
（, \nｌｉｓｔ ｎｕｌｌ !\n”）； goto ｅｎ
ｄ；｝
ｐ 1＝ｈｅａｄ；
ｗｈｉ１ｅ （ｎｕｍ！＝ｐｌ一 >ｎｕｍ＆＆
ｐｌ一 >ｎｅｘｔ！一ＮＵＬＬ）／ *ｐｌ指向的不是
所要找的结点，并且后面还有结点点 *／
{ｐ２ =ｐ１；ｐｌ =ｐｌ一 >ｎｅｘｔ；｝／ *
后移一个结点 *／
ｉｆ （ｎｕｍ＝＝ｐｌ一 >ｎｕｍ） ／ *找到了 *／
{ｉｆ （ｎ１＝＝ｈｅａｄ） ｈｅａｄ =ｐ
ｌ一 >ｎｅｘｔ；／ *若ｐｌ指向的是头结点，把第二
个结点地址赋予ｈｅａｄ *／
ｅ１ｓｅ ｐ２一 >ｎｅｘｔ =ｐｌ一 >ｎｅ
ｘｔ；／ *否则将下一结点地址赋给前一结点地址 *\
ｐｒｉｎｔｆ（ "dｅｌｅｔｅ：％ ld\n”，
ｎｕｍ）；
ｎ =n-１；
}
ｅｌｓｅ ｐｒｉｎｔｆ（, ％ｌｄ ｎｏ
ｔ ｂｅｅｎ ｆｏｕｎｄ！ \n“，ｎｕｍ）；／ *
找不到该结点 *／
ｅｎｄ,
ｒｅｔｕｒｎ （ ｈｅａｄ ） ；
}
函数的类型是指向ｓｔｒｕｃｔ ｓｔｕｄｅｎｔ
类型数据的指针,
它的值是链表的头指针。函数参数为ｈｅａｄ和要删除
的学号ｎｕｍ。ｈｅａｄ的值可能在函数执行过程中
被改变（当删除第一个结点时）。
１ 1．７。５对链表的插入操作
将一个结点插入到一个已有的链表中。设已有的链
表中各结点中的成员项ｎｕｍ（学号）是按学号由小
到大顺序排列的。
用指针变量ｐ０指向待插入的结点，ｐｌ指向第一
个结点。见图１０．２３（ａ）。
将ｐ０一 >ｎｕｍ与ｐｌ一 >ｎｕｍ相比较，如果ｐ０一
>ｎｕｍ＞ｐｌ一 >ｎｕｍ，则待插入的结点不应插在
ｐｌ所指的结点之前。此时将ｐｌ后移，并使ｐ２指
向刚才ｐｌ所指的结点，见图１０．２３（ b）。再
将ｐ１一 >ｎｕｍ与ｐ０一 >ｎｕｍ比。如果仍然是ｐ
０一 >ｎｕｍ大，则应使ｐｌ继续后移，直到ｐ０一 >
ｎｕｍ <=ｐ１一 >ｎｕｍ为止。这时将ｐ０所指的结
点插到ｐｌ所指结点之前。但是如果ｐ１所指的已是
表尾结点，则ｐｌ就不应后移了。如果ｐ０一 >ｎｕ
ｍ比所有结点的ｎｕｍ都大,
则应将ｐ０所指的结点插到链表末尾。
如果插入的位置既不在第一个结点之前，又不在
表尾结点之后，则将ｐ０的值赋给ｐ２一 >ｎｅｘｔ，
即使ｐ２一 >ｎｅｘｔ指向待插入的结点，然后将ｐ
ｌ的值赋给ｐ０ -＞ｎｅｘｔ，即使得ｐ０一 >ｎｅｘ
ｔ指向ｐｌ指向的变量。见图１０．２３（ c）。可
以看到，在第一个结点和第二个结点之间已插入了一
个新的结点。
如果插入位置为第一结点之前（即ｐｌ等于ｈｅａ
ｄ时）,
则将ｐ０赋给ｈｅａｄ，将ｐ１赋给ｐ 0->ｎｅｘｔ。
见图１０．２３（ d）。如果要插到表尾之后，应将
ｐ０赋给ｐｌ一 >ｎｅｘｔ，ＮＵＬＬ赋给ｐ０一 >ｎ
ｅｘｔ，见图１０．２３（ｅ）。
以上算法可用图１０．２４表示。
［例１ 1,１０］插入结点的函数ｉｎｓｅｒｔ如
下。
ｓｔｒｕｃｔ ｓｔｕｄｅｎｔ *ｉｎｓｅｒｔ
（ｈｅａｄ，ｓｔｕｄ）
ｓｔｒｕｃｔ ｓｔｕｄｅｎｔ ＊ｈｅａｄ，
*ｓｔｕｄ,
{ｓｔｒｕｃｔ ｓｔｕｄｅｎｔ ＊ｐ０,*ｐ１,*
ｐ２；
ｐｌ =ｈｅａｄ； /*使ｐｌ指向第一个结
点 *／
ｐ０＝ｓｔｕｄ；／ *p0指向要插入的结
点 *／
ｉｆ （ｈｅａｄ＝ =ＮＵＬＬ）／ *原来
是空表 *／
{ｈｅａｄ =ｐ０；ｐ０一 >ｎｅｘｔ =Ｎ
ＵＬＬ；｝／ *使ｐ０指向的结点作为第一个结点 *／
ｅｌｓｅ
｛ｗｈｉｌｅ （（ｐ０一 >ｎｕｍ＞ｐ
ｌ一 >ｎｕｍ） &&（ｐｌ一 >ｎｅｘｔ！＝ＮＵＬＬ））
{p２＝ p1； p1=ｐｌ一 >ｎｅｘ t； }／ *ｐ
２指向刚才ｐｌ指向的结点,p1后移一个结点 *／
ｉｆ（ｐ０ ->ｎｕｍ＜＝ｐｌ一）ｎｕｍ）
｛ｉｆ （ｈｅａｄ ==ｐｌ） ｈｅａ
ｄ＝ｐ０；／ *插到原来第一个结点之前 *／
ｅｌｓｅ ｐ２ ->ｎｅｘｔ =p0;／ *插到ｐ２指向的结点
之后 *／
ｐ０ —＞ nｅｘｔ =ｐ１； }
elｓｅ
｛ｐｌ一 >ｎｅｘｔ =ｐ０；ｐ０一 >ｎｅｘｔ =Ｎ
ＵＬＬ； }}／ *插到最后的结点 之后 *／
ｎ =ｎ＋１； ／ *结点数加１ *／
ｒｅｔｕｒｎ （ ｈｅａｄ ） ；
}
函数参数是ｈｅａｄ和ｓｔｕｄ,sｔｕｄ也是一个指针
变量，从实参传来待插入结点的地址给ｓｔｕｄ。语
句ｐ０ =ｓｔｕｄ的作用是使ｐ０指向待插入的结点。
函数类型是指针类型，函数值是链表起始地址ｈｅ
ａｄ。
将以上建立、输出、删除、插入的函数组织在一个
程序中，用ｍａｉｎ函数作主调函数。可以写出以下
ｍａｉｎ函数。
ｍａｉｎ（）
{ｓｔｒｕｃｔ ｓｔｕｄｅｎｔ *ｈｅａｄ,ｓｔｕ ;
１ｏｎｇ ｄｅ１ _ｎｕｍ；
ｐｒｉｎｔｆ（, ｉｎｐｕｔ ｒｅｃｏｒｄｓ：
＼ n"）；
ｈｅａｄ＝ｃｒｅａｔ（）； ／ *返回头指针 *
／
ｐｒｉｎｔ（ｈｅａｄ）； ／ *输出全部结点 *／
ｐｒｉｎｔｆ（, ＼ｎｉｎｐｕｔ ｔｈｅ ｄｅｌ
ｅｔｅｄ 0ｎｕｍｂｅｒ：, ）；
ｓｃａｎｆ（, ％ｌｄ,, &dｅ１ _ｍｕｍ）；／
*输入要删除的学号 *／
ｈｅａｄ＝ｄｅｌ（ｈｅａｄ，ｄｅ１ _ｎｕ
ｍ）；／ *删除后的头地址 *／
ｐｒｉｎｔ（ｈｅａｄ）； ／ *输出全部结点 *
／
ｐｒｉｎｉｆ（, /nｉｎｐｕｔ ｔｈｅ ｉｎｓｅｒ
ｔｅｄ ｒｅｃｏｒｄ,")／ *输入要插入的记录 *／
ｓｃａｎｆ（, ％ｌｄ，％ f"，＆ｓｔｕ,ｎｕｍ，
＆ｓｔｕ,ｓｃｏｒｅ）；
ｈｅａｄ =ｉｎｓｅｒｔ（ｈｅａｄ，＆ｓｔｕ）；
／ *返回地址 *／
ｐｒｉｎｔ（ｈｅａｄ）；
}
此程序运行结果是正确的。
它只删除一个结点，插入一个结点。但如果想再插入一
个结点，重复写上程序最后四行，即共插入两个结点。
运行结果却是错误的。
ｉｎｐｕｔ ｒｅｃｏｒｄｓ：（建立链表）
８９１０１，９０
８９１０３，９８
８９１０５，７６
０，０
Ｎｏｗ，Ｔｈｅｓｅ ３ ｒｅｃｏｒｄｓ ａｒｅ,
８９１０１ ９０．０
８９１０３ ９８．０
８９１０５ ７６．０
ｉｎｐｕ ｔｈｅ ｄｅｌｅｔｅｄ ｎｕｍ ber,
８９１０３ （删除）
ｄｅｌｅｔｅ,８９１０３
Ｎｏｗ，Ｔｈｅｓｅ ２ ｒｅｃ oｒｄｓ ａｒｅ,
８９１０１ ９ 0,0 ８９１０５ ７
６．０
ｉｎ pｕｔ ｔｈｅ ｉｎｓｅｒｔｅｄ ｒｅｃｏ
ｒｄ：８９１０２
９０ （ 插入第一个结点 ）
Ｎｏｗ, Ｔｈｅｓｅ ３ ｒｅｃｏｒｄｓ ａｒｅ,
８９１０１ ９０, ０
８９１０２ ９０, ０
８９１０５ ７６．０
ｉｎｐｕｔ ｔｈｅ ｉｎｓｅｒｔｅｄ ｒｅｃｏ
ｒｄ：８９１０４，９９／（插入第二个结点）
Ｎｏｗ，Ｔｈｅ ４ ｒｅｃｏｒｄｓ ａｒｅ,
８９１０１ ９０．０
８９１０４ ９９．０
８９ 1０４ ９９。０
８９１０４ ９９．０
,.,
,.,
（无终止地输出８９１０４的结点数据）
请读者将ｍａｉｎ与ｉｎｓｅｒｔ函数结合起来考
察为什么会产生以上运行结果。
出现以上结果的原因是：ｓｔｕ是一个有固定地址
的变量。第一次把ｓｔｕ结点插入到链表中。第二次
若再用它来插入第二个结点，就把第一次结点的数据
冲掉了。
实际上并没有开辟两个结点。读者可根据ｉｎｓｅｒｔ
函数画出此时链表的情况。为了解决这个问题，必须
在每插入一个结点时新开辟一个内存区。我们修改ｍ
ａｉｎ函数，使之能删除多个结点（直到输入要删的
学号为０），能插入多个结点（直到输入要插入的学
号为０）。
ｍａｉｎ函数如下,
ｍａｉｎ（）
｛ｓｔｒｕｃｔ ｓｔｕｄｅｎｔ *ｈｅａｄ，
*ｓｔｕ；
１ｏｎ g ｄｅ１ _ｎｕｍ；
ｐｒｉｎｔｆ（ "ｉｎｐｕｔ ｒｅｃｏｒｄｓ：
/n”）；
ｈｅａｄ＝ｃｒｅａｔ（）；
ｐｒｉｎｔ （ｈｅａｄ）；
ｐｒｉｎｔｆ（, /nｉｎｐｕｔ ｔｈｅ ｄｅｌ
ｅｔｅｄ ｎｕｍｂｅｒ,");
ｓｃａｎｆ（, ％ 1d”，＆ｄｅ l_ｎｕｍ）；
ｗｈｉｌｅ （ｄｅ１ _ｎｕｍ！＝０）
｛ｈｅａｄ =ｄｅｌ（ｈｅａｄ，ｄｅ l_ｎｕｍ） ;
ｐｒｉｎｔ（ｈｅａｄ） ;
ｐｒｉｎｔｆ（, ｉｎｐｕｔ ｔｈｅ ｄｅｌ
ｅｔｅｄ ｎｕｍｂｅｒ,");
ｓｃａｎｆ（, ％ ld"，＆ｄｅ l_ｎｕｍ）；
ｐｒｉｎｔｆ（, ＼ｎｉｎｐｕｔ ｔｈｅ ｉ
ｎｓｅｒｔｅｄ ｒｅｃｏｒｄ,");
ｓｔｕ＝（ｓｔｒｕｃｔ ｓｔｕｄｅｎｔ *）ｍａｌ
ｌｏｃ（ＬＥＮ） ;
ｓｃａｎｆ（, ％ 1d,％ f,”，＆ｓｔｕ一 >ｎｕｍ，
＆ｓｔｕ一 >ｓｃｏｒ );
ｗｈｉｌｅ （ｓｔｕ一 >ｎｕｍ！＝０）
｛ ｈｅａｄ＝ｉｎｓｅｒｔ （ ｈｅａｄ, ｓｔ
ｕ ）,
ｐｒｉｎｔ （ ｈｅａｄ ） ；
ｐｒｉｎｉｆ（ "ｉｎｐｕｔ ｔｈｅ ｉｎｓｅｒｔ
ｅｄ ｒｅｃｏｒｄ,");
ｓ tu=（ｓｔｒｕｃｔ ｓｔｕｄｅｎｔ *）ｍａ
ｌｌｏｃ（ＬＥＮ） ;
ｓ cａｎｆ（, ％ 1d，％ f,＆ｓｔｕ一 >ｎｕｍ，
＆ｓｔｕ一 >ｓｃｏｒｅ） ;
}
}
sum定义为指针变量，在需要插入时先用ｍａ llｏｃ函
数开辟一个内存区，将其起始地址经强制类型转换后
赋给 stｕ，然后输入此结构体变量中各成员的值。对
不同的插入对象,stu的值是不同的，每次指向一个
新的结构体变量。在调用 insert函数时，实参为ｈ ea
ｄ和 stu,将已建立的链表起始地址传给 insert函数的
形参，将 stu（既新开辟的单元的地址）传给形参
stud,函数值返回经过插入之后的链表的头指针（地
址）,
运行情况如下,
ｉｎｐｕｔ ｒｅｃｏｒｄｓ,
８９１０１，９９
８９１０３，８７
８９１０５，７７
０，０
Ｎｏｗ,Ｔｈｅｓｅ ３ ｒｅｃｏ rｄｓ
ａｒｅ。
８９１０１ ９９．０
８９１０３ ８７．０
８９１０５ ７７．０
inｐｕｔ ｔｈｅ ｄｅｌｅｔｅｄ ｎｕｍｂｅｒ：
８９１０３
ｄｅｌｅｔｅ：８ 9103
Ｎｏｗ，Ｔｈｅｓｅ ２ ｒｅｃｏｒｄｓ ａ
ｒｅ,
８９１０１ ９９．０
８９１０５ ７７．０
ｉｎｐｕｔ ｔｈｅ ｄｅ１ｅｔｅｄ ｎｕｍｂｅｒ：
８９１０５
ｄｅｌｅｔｅ：８９１０５
Ｎｏｗ，Ｔｈｅｓｅ ｌ ｒｅｃｏｒ ds ａｒ
ｅ,
８９１０１ ９９．０
ｉｎｐｕｔ ｔｈｅ ｄｅ１ｅｔｅｄ ｎｕｍｂｅ
ｒ：０
１ｎｐｕｔ ｔｈｅ ｉｎｓｅｒｔｅｄ ｒｅｃｏｒ
ｄ：８９１０４，８７
ＮＯｗ，Ｔｈｅｓｅ ２ ｒｅｃｏｒｄｓ ａｒ
ｅ,
８９１０１ ９９。０
８９１０４ 8７．０
ｉｎｐｕｔ ｔｈｅ ｉｎｓｅｒｔｅｄ ｒｅｃ
ｏｒｄ：８９１０６，６５
Ｎｏｗ,Ｔｈｅｓｅ ３ ｒｅｃｏｒｄｓ ａｒｅ,
８９１ 01 ９９, ０
８９１０４ ８７, ０
８９１０６ ６５, ０
ｉｎ pｕｔ ｔｈｅ ｉｎｓｅｒｔｅｄ ｒｅｃ
ｏｒｄ：０, ０
对这个程序请读者仔细消化 。
指针的应用领域很宽广, 除了单向链表之外, 还有
环形链表, 双向链表 。 此外还有队列, 树, 栈, 图等
数据结构 。
有关这些问题的算法可以学习, 数据结构 >>课程, 在此
不作详述 。
$１ 1．８ 共用体
１ 1．８,1 共用体的概念
有时需要使几种不同类型的变量存放到同一段内存
单元中。例如，可把一个整型变量、一个字符型变量、
一个实型变量放在同一个地址开始的内存单元中（见
图１０,２５）。以上三个变量在内存中占的字节数
不同，但都从同一地址开始（图中设地址为１０００）
存放。 1000
i
ch
f
也就是使用覆盖技术，几个变量互相覆盖。这种使几个
不同的变量共占同一段内存的结构,称为, 共用体,
类型的结构。
, 共用体, 类型变量的定义形式为,
union 共用体名
{ 成员表列 ;
} 变量表列；
例如,
ｕｎ ioｎ data
｛ iｎｔ i;
ｃｈ ar ｃｈ ;
floaｔ ｆ ;
｝ａ,b,ｃ ;
也可以将类型定义与变量定义分开,
ｕｎ ioｎ ｄａ ta
｛ｉｎｔ i;
ｃ hａｒ ｃ h;
floaｔ ｆ ;
};
union data a,b,c;
即先定义一个ｕｎｉｏｎ ｄａｔａ类型,
再将 a bｃ定义为 union ｄ ata类型。当然也可以直接
定义共用体变量，如,
union
{int i;
char f;
}a,b,c;
可以看到,,共用体, 与, 结构体, 的定义形式相
似。但它们的含义是不同的。
结构体变量所占内存长度是各成员占的内存长度之
和。每个成员分别占有其自己的内存单元。共用体变
量所占的内存长度等于最长的成员的长度。例如，上
面定义的, 共用体 "变量 a,b,c各占４个字节（因为一
个实型变量占４个字节），而不是各占２＋ 1＋４ =７
个字节。
目前国内有关Ｃ语言的书多把ｕｎｉＯｎ直译为“联
合”。作者认为，译为“共用体”
更能反映这种结构的特点, 即几个变量共用一个内存区 。
而, 联合, 这一名词；在一般意义上容易被理解为
,将两个或若干个变量联结在一起,, 难以表达这种
结构的特点 。 日本就是用, 共用体 "这一术语的 。
１ 1．８．２共用体变量的引用方式
只有先定义了共用体变量才能引用它。而且不能引
用共用体变量，而只能引用共用体变量中的成员。例
如，前面定义了 a,b,c为共用体变量，下面的引用方
式是正确的,
ａ,i（引用共用体变量中的整型变量 i）
ａ,ｃｈ（引用共用体变量中的字符变量ｃｈ）
ａ,f（引用共用体变量中的实型变量ｆ）
不能只引用共用体变量，例如,
ｐｒｉｎｔｆ（ " %d",a）
是错误的，ａ的存储区有好几种类型，分别占不同长度
的存储区，仅写共用体变量名 a,难以使系统确定究竟
输出的是哪一个成员的值。应该写成ｐｒｉｎｉｆ（,
％ d，ａ,i)或ｐｒｉｎｔｆ（, %c"，ａ,ｃｈ）等
１ 1．８,３共用体类型数据的特点
在使用共用体类型数据时要注意以下一些特点,
１．同一个内存段可以用来存放几种不同类型的成
员，但在每一瞬时只能存放其中一种，而不是同时存
放儿种。也就是说，每一瞬时只有一个成员起作用，
其它的成员不起作用，即不是同时都存在和起作用。
２．共用体变量中起作用的成员是最后一次存放的
成员，在存入一个新的成员后原有的成员就失去作用。
如有以下赋值语句）ａ,i=１；
ａ,ｃｈ ='a';
ａ,ｆ＝１．５ ;
在完成以上三个赋值运算以后，只有ａ,f是有效的，ａ,
ｉ和ａ,ｃ已经无意义了。此时用 printf（, ％ｄ,,
ａ,ｉ）是不行的，而用ｐ riｎ tｆ（, ％ f”,a.f）
是可以的，因为最后一次的赋值是向ａ,f赋值。因此
在引用共用体变量时应十分注意当前存放在共用体变
量中的究竟是哪个成员。
３．共用体变量的地址和它的各成员的地址都是同一地
址。例如,&a.&a.i&a.ch.&a.f都是同一地址值，其
原因是显然的。
４．不能对共用体变量名赋值，也不能企图引用变
量名来得到成员的值，又不能在定义共用体变量时对
它初始化。例如，下面这些都是不对的,
①ｕｎｉｏｎ
｛ｉｎｔ i；
ｃｈ aｒ ｃｈ ;
float ｆ ;
｝ａ＝ {1,?a?,1.5}; （不能初始化）
②ａ＝１； （不能对共用体变量赋值）
③ｍ＝ａ； （不能引用共用体变量名以得到值）
５．不能把共用体变量作为函数参数，也不能使函
数带回共用体变量，但可以使用指向共用体变量的指
针（与结构体变量这种用法相仿）。
６,共用体类型可以出现在结构体类型定义中，也可以
定义共用体数组。反之，结构体也可以出现在共用体
类型定义中，数组也可以作为共用体的成员。
「例１ 1,11］设有若干个人员的数据，其中有学生和
教师。学生的数据中包括：姓名,
号码, 性别, 职业, 班级 。 教师的数据包括：姓名, 号
码, 性别, 职业, 职务 。 可以看出, 学生和教师所包
含的数据是不同的 。 现要求把它们放在同一表格中,
见图１０, ２６ 。
如果, ｊ ob”项为, ｓ, （学生），则第５项为ｃｌａ
ss（班）。即Ｌｉ是５０ 1班的。如果, ｊ oｂ, 项是
,Ｔ, （教师），则第５项为 position（职务）。ｗ
ａｎ g是ｐ rｏ f（教授）。显然对第５项可以用共用
体来处理（将ｃ laｓｓ和ｐＯｓｉｔｉ０ｎ放在同一
段内存中）。
要求输入人员的数据，然后再输出。可以写出下面
的算法（见图１ 1．２７）。按此写出程序。为简化
起见。只设两个人（一个学生、一个教师）
/* example 11.11 */
#define N 2
struct
{ int num;
char name[10];
char sex;
char job;
union
{ int class;
char position[10];
} category;
} person[2];
main()
{ int n,i;
for(i=0;i<N;i++)
{
printf("Inupt the num name sex and job(s or t) \n");
scanf ("%d%s %c %c",
&person[i].num,person[i].name,&person[i].sex,&person[i]
.job);
if (person[i].job =='s')
{printf("input class num\n");
scanf ("%d",&person[i].category.class);}
else if (person[i].job =='t')
{printf("input position\n");
scanf("%s",person[i].category.position);}
else printf("input error!");
}
printf("\n");
printf("No,name sex job class/position\n");
for (i=0;i<N;i++)
{if (person[i].job=='s')
printf("%-6d%- 10s%-3c%-3c %-
10d\n",person[i].num,
person[i].name,person[i].sex,person[i].job,
person[i].category.class);
else printf("%-6d%-10s%-3c%-3c %-
10s\n",person[i].num,
person[i].name,person[i].sex,person[i].job,
person[i].category.position);
}
}
运行情况如下,
１０１ Ｌｉ ｆ ｓ ５０１
１０２ Ｗａｎｇ ｍ ｔ ｐｒｏｆｅｓｓｏｒ
Ｎｏ。 Ｎａｍｅ ｓｅｘ ｊｏｂ ｃｌａｓｓ
／ｐｏｓｉｔｉｏｎ
可以看到：在ｍａ in函数之前定义了外部的结构体数组
pｅｒｓｏｎ，在结构体类型定义中包括了共用体类
型，ｃａｔｅｇｏｒｙ（分类）是结构体中一个成员
名，在这个共体中一个成员为ｃｌａｓｓ和ｐｏｓｉ
ｔｉｏｎ，前者为整型，后者为字符数组（存放, 职
务, 的值 ——字符串）。
这种共用体变量的用法是很有用的 。 例如, 可以设
一个单元 data,内放一个常量, 此常量可以是整型,
实型或字符型, 双精度等 。
在程序中根据, 类型标志, 来决定按何种类型处理。
如,
ｓｔｒｕｃｔ
{..,
ｕｎ ion
｛ int I;
ｃｈａｒ ｃｈ ;
float f;
ｄｏｕｂｌｅ ｄ ;
｝ｄａｔａ；
ｉｎｔ ｔｙ pｅ；
）ａ；
ｓｗｉｔｃｈ（ａ,ｔｙｐｅ）
case 0,printf（, ％ｄ \n”，ａ,data.i）； break;
Case 1:printf（, ％ｃ \n"，ａ,data.ch）； break;
Case 2:printf（, ％ f\n”ａ,data.f）； break;
Case 3:printf（, ％ｆ \n”，ａ,data.ｄ）； break;
}
结构体中的ｔｙｐ e作为, 类型标志,,如果在共用体
成员中存放整数，则使ｔｙ pe=０；若存放字符，则
使ｔｙｐ e＝１；若存放实型，则使ｔｙｐ＝２；若
存放双精度型，使ｔｙｐ e=３。然后在ｓｗｉｔｃｈ
语句中根据ａ,type的值来决定按哪一种类型输出。
这在写系统软件时，用来处理符号表是有用的。在符
号表中可以包含符号名、类型和值。根据不同情况进
行不同处理。
１ 1．９ 枚举类型
枚举类型是 ANSI Ｃ新标准所增加的。
如果一个变量只有几种可能的值，可以定义为 枚举类型 。所
谓, 枚举, 是指将变量的值一一列举出来，变量的值只限于列
举出来的值的范围内。
定义枚举类型用 enum(enumerate)开头。例如
enum weekday {sun,mon,tue,wed,thu,fri,sat};
定义了一个枚举类型 enum weekday，可以用此类型来定义变量。
如
enum weekday workday,week_end;
workday和 week_end被定义为枚举变量，它们的值只能是 sun
到 sat之一。例如,
workday=mon;
week_end=sun;
是正确的。
当然，也可以直接定义枚举变量，如
enum weekday
{sun,mon,tue,wed,thu,fri,sat} workday,week_end ；
其中ｓｕｎ, ｍｏｎ, …,sat,等称为 枚举元素或枚举
常量 。 它们是用户定义的标识符 。 这些标识符并不自
动地代表什么含义 。 例如, 不因为写成ｓｕｎ, 就自
动代表, 星期天 ".不写ｓｕｎ而写成ｓｕｎｄａｙ也
可以 。 用什么标识符代表什么含义, 完全由程序员决
定, 并在程序中作相应处理 。
说明
１ ·在Ｃ编译中，对枚举元素按常量处理，故称枚
举常量。它们不是变量，不能对它们赋值。例如
ｓｕｎ =０；ｍｏｎ＝１ ;
是错误的。
２．枚举元素作为常量，它们是有值的,C语言编译按
定义时的顺序使它们的值为０，１，２,……。
在上面定义中,sun的值为０，ｍｏｎ的值为１，
sat为６。如果有赋值语句
ｗｏｒｋｄａｙ＝ｍｏｎ；
ｗｏｒｋｄａｙ变量的值为１。这个整数是可以输出的。
如
printf（, ％ d”，ｗｏｒｋｄａｙ）；
将输出整数１。
也可以改变枚举元素的值，在定义时由程序员指定，如
enum weekday {sun=7,mon=1,tue,wed,thu,fri,sat}
workday,week_end;定义 sun为 7,mon=1,以后顺序加 1，
sat为 6,
3.枚举值可以用来作判断比较。如
ｉｆ（ｗｏｒｋｄａｙ ==ｍｏｎ） …
ｉｆ（ｗｏｒｋｄａｙ＞ｓｕｎ） ···
枚举值的比较规则是：按其在定义时的顺序号比较。如
果定义时未人为指定，则第一个枚举元素的值认作０。
故ｍｏｎ大于ｓｕｎ，ｓａｔ＞ｆｒｉ。
４．一个整数不能直接赋给一个枚举变量。如
ｗｏｒｋｄａｙ＝２；
是不对的。它们属于不同的类型。应先进行强制类型转
换才能赋值。如
ｗｏｒｋｄａｙ＝（ｅｎｕｍ ｗｅｅｋｄａｙ）２；
它相当干将顺序号为２
的枚举元素赋给 workday，相当于
workday＝ tue；
甚至可以是表达式。如
workday＝（ enum weekday） (5-3)；
［例１ 1．１２ 】 口袋中有红、黄、蓝、白、黑五种
颜色的球若干个。每次从口袋中取出３个球，问得到
三种不同色的球的可能取法，打印出每种组合的三种
颜色。
球只能是５种色之一，而且要判断各球是否同色，应该
用枚举类型变量处理。
设取出的球为 I,j,k.根据题意,I,j,k分别是５种
色球之一，并要求 I!=j!=k.可以用穷举法，即一种可
能一种可能地试，看哪一组符合条件。
算法可用图１０。２８表示。
用ｎ累计得到三种不同色球的次数。外循环使第一个
球ｉ从ｒｅｄ变到ｂｌａｃｋ。中循环使第二个球ｊ
也从ｒｅｄ变到ｂｌａｃｋ。如果ｉ和ｊ同色则不可
取；
只有 I,j不同色 (I!=j)时才需要继续找第三个球，此时第三
个球ｋ也有５种可能（ｒｅｄ到ｂｌａｃｋ），但要
求第三个球不能与第一个球或第二个球同色，即
ｋ !=I,k!=j.满足此条件就得到三种不同色的球。输出
这种三色组合方案。然后使 n加１。外循环全部执行
完后，全部方案就已输
出完了 。 最后输出总数 n,
下面的问题是如何实现图１０, ２８中的, 输出一
种取法, 。 这里有一个问题,
如何输出, ｒｅｄ,,, ｂｌｕｅ,, ……等单词。不
能写成ｐｒｉｎｔｆ（ "％ s"，ｒｅｄ）来输出, ｒ
ｅｄ, 字符串。可以采用图１０．２９的方法。
为了输出３个球的颜色，显然应经过三次循环，第
一次输出ｉ的颜色，第二次输出ｊ的颜色，第三次输
出ｋ的颜色。在三次循环中先后将 I,j,ｋ赋予ｐｒｉ。
然后根据ｐｒｉ的值输出颜色信息。在第一次循环时，
ｐｒｉ的值为１，如果ｉ的值为ｒｅｄ，则输出字符
串, ｒｅｄ,,其它的类推。
程序如下,
ｍａｉｎ（）
{eｎｕｍ ｃｏｌｏｒ {ｒｅｄ，ｙｅｌｌｏｗ，
ｂｌｕｅ，ｗｈｉｔｅ，ｂｌａｃｋ };
enum color ｉ，ｊ，ｋ，ｐｒｉ ;
int n,loop;
n=0;
for (I=red;I<=black;I++)
for (j=red;j<=balack;j++)
if (I!=j)
{for (k=red;k<=black,k++)
if ((k!=I)&&(k!=j))
{n=n+1;
printf("%-4d",n);
for (loop=1;loop<=3;loop++)
{switch(loop)
{case 1:pri=i;break;
case 2:pri=j;break;
case 3:pri=k;break;
default:break;
}
switch(pri)
{casered:printf("%-10s,"red");break;
case yellow:printf("%-
10s","yellow");break;
case blue:printf("%-
10s","blue");break;
case white:printf("%-
10s","white");break;
case black:printf("%-
10s","black");break;
default:break;
}
}
printf("\n");
}
}
printf("\ntoal:%5d\n",n);
}
运行结果如下,
1 red yellow blue
2 red yellow white
3 red yellow black
4 red blue yellow
5 red blue white
6 red blue black
7 red white yellow
8 red white blue
9 red white black
10 red black yellow
。。。。。。。。。。。。。。。。。
６０ black white blue
ｔｏｔａ１：６０
有人说，不用枚举变量而用常数０表, 红,, 1表
,黄 ………,不也可以吗？是的，完全可以。但显然用
枚举变量更直观，因为枚举元素都选用了令人, 见名
知意, 标识符，而且枚举变量的值限制在定义时规定
的几个枚举元素范围内，如果赋予它一个其它的值，
就会出现出错信息，便于检查。
$11.10 用 typdef定义类型
除了可以直接使用Ｃ提供的标准类型名（如
int.char,float.double.long等）和自己定义的结
构体、共用体、指针、枚举类型外还可以用 typedef
定义新的类型名来代替已有的类型名如,
typedef int INTEGER;
typedef float REAL;
指定用 INTEGER 代表 int类型,REAL代表 float,这样，
以下两行等价,
① int i,j;； float ａ,b;
② INTEGER i,j; REAL ａ,b;
这样可以使熟悉Ｆ０ＲＴＲＡＮ的人能用 INTEGER 和
REALL定义变量，以适应他们的习惯。
如果在一个程序中，一个整型变量用来计数，可以,
Typedef int COUNT;
COUNT i,j;
即将变量 i.j定义为 COUNT类型，而 COUNT等价于 int，因此 i、ｊ是
整型。但在程序中将 i,j定为 COUNT类型，可以使人更一目了然
地知道它们是用于计数的。
可以定义结构体类型,
ｔｙｐｅｄｅｆ ｓｔｒｕｃｔ
｛ｉｎｔ ｍｏｎｔ；
ｉｎｔ ｄａｙ；
iｎｔ ｙｅａｒ；
｝ DATE;
定义新类型名 DATE，它代表上面定义的一个结构体类型。这时就
可以用 DATE定义变量,
DATE birthday；（不要写成 struct DATA birthday;）
DATA *ｐ ; (p为指向此结构体类型数据的指针）
还可以进一步,
１ typedef NUM［ 1００］；（定义 NUM为整型数
组类型）
NUM n; （定义ｎ为整型数组变量）
２,typedef char *STRING； （ 定义 STRING为字符指
针类型 ）
STRING ｐ, s[１０ ]； （ p为字符指变量, s为指针
数组 ）
３, typed int (*POINTER)() （ 定义 POINTER
为指向函数的指针类型, 该函数返回整型值 ）
POINTER p1,p2； (p1,p2为 POINTER 类型的指针变量 ）
归纳起来, 定义一个新的类型名的方法是,
① 先按定义变量的方法写出定义体（如,int i；）。
②将变量名换成新类型名（如：将ｉ换成 COUNT）。
③在最前面加 typedef（如,typedef int COUNT）。
④然后可以用新类型名去定义变量。
再以定义上述的数组类型为例来说明,
①先按定义数组变量形式书写,int n[100];
② 将变量名ｎ换成自己指定的类型名,int NUM[100]
③ 在前面加上 typedef，得到 typedef int NUM[100];
④ 用来定义变量,NUM ｎ,
同样，对字符指针类型，也是：①ｃｈａｒ *p;
② ｃｈａｒ * STRING；③ typedef *STRING；
④ STRING ｐ，ｓ［１０］；
习惯上常把用 typedef定义的类型名用大写字母表
示，以便与系统提供的标准类型标识符相区别。
说明,
１．用 typｅｄｅｆ可以定义各种类型名，但不能
用来定义变量。用 typedf可以定义出数组类型、字符
串类型，使用比较方便。如定义数组，原来是用
ｉｎｔ ａ [１０］,b[１０ ],c[1０,d[１０ ];
由于都是一维数组，大小也相同，可以先将此数组类型
定为一个名字,
ｔｙ pｅｄｅｆ ｉｎｔ ＡＲＲ [1０］；
然后用ＡＲＲ去定义数组变量,
ＡＲＲａ,b，ｃ，ｄ；
ＡＲＲ为数组类型，它包含１０个元素。因此，
ａ,b,ｃ,ｄ都被定义为一维数组，含１０个元素。
可以看到，用 typｅｄｅｆ可以将数组类型和数组
变量分离开来，利用数组类型可以定义多个数组变量。
同样可以定义字符串类型、指针类型等。
２．用 typｅｄｅｆ只是对已经存在的类型增加一
个类型名，而没有创造新的类型。
例如，前面定义的整型类型 COUＮＴ，它无非是对ｉｎ
ｔ型另给一个新名字。又如
ｔｙｐｅｄｅｆ ｉｎｔ ＮＵＭ［１０］；
无非是把原来用 "int n[１０ ]； "定义的数组变量的类
型用一个新的名字ＮＵＭ表示出来。无论用哪种方式
定义变量，效果都是一样的。
３,tｙｐｅｄｅｆ与＃ｄｅｆｉｎｅ有相似之处，
如
ｔｙｐｄ ef int CＯＵＮＴ；
和 ＃ｄｅｆｉｎｅ ＣＯＵＮＴ ｉｎ t
的作用都是用 COＵＮＴ代表ｉｎｔ。但事实上，它们二
者是不同的。＃ｄｅｆｉｎｅ是在预编译时处理的，
它只能作简单的字符串替换，而ｔｙｐｅｄｅｆ是在
编译时处理的。实际上它并不是作简单的字符串替换，
例如
ｔｙｐｅｄｅｆ ｉｎｔ ＮＵＭ [１０ ]
并不是用ＮＵＭ [１０］去代替ｉｎｔ，而是采用如同
定义变量的方法那样来定义一个类型
（就是前面介绍过的将原来的变量名换成类型名 ),
４．当不同源文件中用到同一类型数据（尤其是像数
组、指针、结构体、共用体等类型数据）时，常用ｔ
ｙ Pｅｄｅｆ定义一些数据类型，把它们单独放在一
个文件中，然后在需要用到它们的文件中用＃ｉｎｃ
ｌｕｄｅ命令把它们包含进来。
５, 使用ｔｙ Pｅｄｅｆ有利于程序的通用与移植 。
有时程序会依赖于硬件特性, 用ｔｙｐｅｄｅｆ便于
移植 。 例如,
有的计算机系统１ｎｔ型数据用两个字节，数值范围为
一３２７６８～３２７６７，而另外一些机器则以４
个字节存放一个整数，数值范围为 + -２１亿。如果
把一个Ｃ程序从一个以４个字节存放整数的计算机系
统移植到以２个字节存放整数的系统，按一般办法需
要将定义变量中的每个 iｎｔ改为１ｏｎｇ。例如，
将, iｎｔ ａ,b,c;”，如果程序中有多处用ｉｎ
ｔ定义变量，则要改动多处。现可以用一个ｔｙｐｅ
ｄｅｆ定义,
ｔｙｐ eｄ ef ｉｎｔ ＩＮＴＥＧ EＲ ;
在程序中用ＩＮＴＥＧＥＲ定义变量。在移植时只需改
动 typｅｄｅｆ定义体即可,
ｔｙｐ eｄ ef long ＩＮＴＥＧＥＲ ;
