在c语言中，结构体数据类型与共用体数据类型都属于构造类型。共用体与结构体数据类型在定义上十分相似，但它们在存储空间的占用分配上有本质的区别。结构体变量是各种类型数据的集合，各成员占据不同的存储空间，而共用体变量的所有成员占用相同的存储空间，在某一时刻只有一个成员起作用。
（1）共用体类型的定义
定义共用体类型的一般形式：
union 共用体类型名
{
数据类型 成员名1;
数据类型 成员名2;
数据类型 成员名3;
......
};
以上定义了一个名为data的共用体类型。它说明该类型由三个不同类型的成员组成，这些成员共享同一块存储空间。
（2）共用体变量的定义
与结构体变量的定义类似；
（3）共用体变量的引用和初始化
1.引用共用体变量中的一个成员
引用共用体变量的成员的一般形式
共用体变量名.成员名
共用体指针变量->成员名
第一种引用方式应用于普通共用体变量，第二种引用方式应用于共用体指针变量。
union data a,*p=&a;
2.共用体类型变量的整体引用
可以将一个共用体变量作为一个整体赋给另一个同类型的共用体变量。例如：
union data a,b;
......
a=b;
3.共用体变量的初始化
在共用体变量定义的同时只能用第一个成员的类型值进行初始化，共用体变量初始化的一般形式：
union 共用体类型名 共用体变量={第一个成员的类型名};
例如：
union data a={8};
请注意：
1）在对共用体变量进行初始化时，尽管只能给第一个成员变量赋值，但必须用花括号括起来。
2）不能对共用体变量名赋值，不能通过引用变量名得到其成员的值。
3）不可以在定义共用体变量时对它初始化。（意思可能是在定义共用体类型的同时定义结构体变量时，不能初始化，以后细细探索。）
说明
*共用体变量的地址及其各成员的地址都是同一地址，因为各成员地址的分配都是从共用体变量空间的起点开始的。
*不能使用共用体变量作为函数参数，也不能使用函数返回共用体变量，但可以使用它指向共用体变量的指针(与结构体变量用法相似);
*共用体变量可以出现在结构体类型的定义中，也可以定义结构体数组。
例子：输入学生的不同类型的成绩（百分制，等级制），运行程序后屏幕输出学生的成绩表。以flag为标志不同类型的成绩，flag=0作为百分制成绩的标志，非0是等级制成绩的标志。
1 #include<stdio.h>
2
3 struct c
4 {
5 char flag;
6 int num;
7 union stu
8 {
9 int score;
10 char s;
11 }cg;
12 }pe[3];
13
14 int main(){
15 int i,m;
16 for(i=0;i<3;i++){
17 printf("在输入成绩之前先输入0或1代表是百分制还是等级制！\n");
18 scanf("%d",&pe[i].flag);
19 if(pe[i].flag==0){
20 printf("请连续输入学号和百分制成绩，以逗号间隔！\n");
21 scanf("%d,%d",&pe[i].num,&pe[i].cg.score);
22 }else{
23 printf("请连续输入学号和等级制成绩，以逗号间隔！\n");
24 scanf("%d,%c",&pe[i].num,&pe[i].cg.s);
25 }
26 }
27 for(i=0;i<3;i++){
28 if(pe[i].flag==0){
29 printf("%4d%4d\n",pe[i].num,pe[i].cg.score);
30 }else
31 printf("%4d %c\n",pe[i].num,pe[i].cg.s);
32 }
33 return 0;
34 }
在这个例子中需要注意的有两点：
1.在同时用是scanf输入两个数据时最好自定义它们的分隔方法，例如逗号。
2.在共用体类型的定义中我原先用的是 char s[10],而不是char s;但虽然在是scanf语句中用%c来接收s但并不报错，只是输出结果会出问题。这里要注意%S和%C的正确使用。
(4)枚举类型
当一个变量的取值只限定为几种可能时，就可以使用枚举类型。枚举类型是将可能的取值一一列出来，那么变量的取值范围也就在列举值的范围之内。
1.枚举类型的说明：
枚举类型说明的一般形式：
enum 枚举类型名{枚举值1，枚举值2......};
例如:
enum flag{true,false};//只允许两个值
enum weekday{sun,mon,tue,wed,thu,fri,sat};//只允许7个值
枚举类型的说明只是规定了枚举的类型和该类型只允许取哪几个值，它并不分配内存。
2.枚举类型变量的定义
1)进行枚举类型说明的同时定义枚举类型变量。
enum flag{true,false}a,b;
2)用无名枚举类型
enum {true,false} a,b;
3)枚举类型说明和枚举型变量定义分开。
enum flag{true,flase};
enum flag a,b;
以上三种形式的定义其作用是相同的，他们所定义的枚举变量a和b，都只能取true或者false两个值。在编译时，为变量的定义分配内存，一个枚举类型变量所占的空间与int型相同。
说明:
*枚举类型本身就是常量，不允许对其进行赋值操作;
例如:true=1;false=0;都是错误的。
*在c语言中枚举值被处理成一个整型的常量，此常量的值取决于说明各枚举值排列的先后次序，第一个枚举值序号为0，因此它的值为0，以后依次加一。
例如:enum weekday{sun,mon,tue,wed,thu,fri,sat}workday;其中sun的值为0，sat的值为6。
要想使sun的值为7，mon的值为1，则可以这样指定{sun=7,mon=1,tue,wed,thu,fri,sat};对于没有指定值的元素，其取值规则仍按所处的顺序取。
*枚举值之间可以相互比较
tue>wed。这实际上是在进行2>3的比较
*整数不能直接赋值给枚举变量
例如:workday=3;
这是错误的。因为workday是枚举类型的变量，而3是整型变量，不同的数据类型在赋值时，必须将赋值号右边强制转换为左边变量的类型后再赋值。
例如:workday=(enum weekday)(5-3);
示例：盒子里有若干个五种颜色（红，黄，蓝，白，黑）的彩球。每次从盒子里取出3个球，问得到3种不同颜色的球的可能取法，并输出每种组合的3种颜色。
1 #include<stdio.h>
2
3 int main(){
4 enum color{red=0,yellow=1,blue=2,white=3,black=4};
5 //i,j,k用来标识抽出的每种球的颜色，t用来遍历他们三个！
6 enum color i,j,k,t;
7 //n用来记录总的可能，lp是用来在每种可能中的循环变量
8 int n=0,lp;
9 for(i=red;i<=black;i++)
10 {
11 for(j=red;j<=black;j++){
12 if(i!=j){
13 for(k=red;k<=black;k++){
14 if((k!=i)&&(k!=j))
15 {
16 printf("%-4d",n=n+1);
17 for(lp=1;lp<=3;lp++){
18 switch(lp)
19 {
20 case 1:t=i;break;
21 case 2:t=j;break;
22 case 3:t=k;break;
23 default:break;
24 }
25 switch(t){
26 case red: printf("%10s","red");break;
27 case yellow: printf("%10s","yellow");break;
28 case blue: printf("%10s","blue");break;
29 case white: printf("%10s","white");break;
30 case black: printf("%10s","black");break;
31 }
32 }
33 printf("\n");
34 }
35 }
36 printf("total: %5d\n",n);
37 }
38 }
39 }
40 return 0;
41 }
上述代码产生了这个错误：
原因是在c语言中无法进行枚举类型的自增自减运算，因为在i++时，i自动被转化为整型，需要进行强制类型转换才能进行重新赋值给i。
解决方法有:
1:将代码 enum color i,j,k,t;改为int i,j,l,t;
2或者将i++改为i=(enum color)(i+1);
1 #include<stdio.h>
2
3 int main(){
4 enum color{red,yellow,blue,white,black};
5 //i,j,k用来标识抽出的每种球的颜色，t用来遍历他们三个！
6 enum color i,j,k,t;//（1）或者直接改为int i,j,k,t;
7 //n用来记录总的可能，lp是用来在每种可能中的循环变量
8 int n=0,lp;
9 //(2)进行强制类型转换
10 for(i=red;i<=black;i=(enum color)(i+1))
11 {
12 for(j=red;j<=black;j=(enum color)(j+1)){
13 if(i!=j){
14 for(k=red;k<=black;k=(enum color)(k+1)){
15 if((k!=i)&&(k!=j))
16 {
17 printf("%-4d",n++);
18 for(lp=1;lp<=3;lp++){
19 switch(lp)
20 {
21 case 1:t=i;break;
22 case 2:t=j;break;
23 case 3:t=k;break;
24 default:break;
25 }
26 switch(t){
27 case red: printf("%10s","red");break;
28 case yellow: printf("%10s","yellow");break;
29 case blue: printf("%10s","blue");break;
30 case white: printf("%10s","white");break;
31 case black: printf("%10s","black");break;
32 }
33 }
34 printf("\n");
35 }
36 }
37 }
38 }
39 }
40 printf("total: %5d\n",n);
41 return 0;
42 }
总而言之，课本上的代码也不是全对，总是遇到各种问题，不过总算是解决了。
不过根据错误来看，应该还可以用++操作符重载的方式来解决这个问题。以后再看。
（5）用typedef定义类型
在c语言中，可以用typedef定义新的类型名来代替已有的类型名。定义的一般形式为：
typedef 类型名 新名称;
typedef是类型定义中的关键字，“类型名”是c语言中的已有的类型（如int，float），“新名称”是用户自定义的新名，新名称在习惯上用大些字母表示。
举例：
1）定义一个新的结构体类型DATE:
typedef struct
{
int month;
int day;
int year;
}DATE;
DATE d1,d2;
2)typedef int ARR[10];定义ARR是整型数组类型
ARR m,n;//m和n都被定义为一维数组，包含10个元素。
3）typedef char *STR;//定义STR是字符指针类型
STR p,x[10];//定义p为字符指针变量，x为字符指针数组。
4）typedef int *PI;//定义PI为整型指针类型
PI p,*q,r[20];//定义p为整型指针变量，q为指向int型指针的指针变量,r为具有20个指向整型类型元素的指针数组。
说明：
*用typedef可以声明各种类型名，但不能用来定义变量
*用typedef只是对已经存在的类型增加一个类型的新名称，而没有构造新的类型。
*如果在不同源文件中使用同一类型数据，常用typedef说明这些数据类型，并把它们单独放在一个文件中，然后在需要时，用#include命令把他们包含进来。
（6）链表及其简单操作
数组是一批有先后次序的元素构成的序列，可以用下标随意访问元素而且操作简单。但在利用数组存放数据时必须事先定义固定的数组长度，势必会造成内存空间的浪费。而且不利于插入和删除数据。
链表是结构体类型的重要应用之一，也是一种有先后次序的序列，但是链表中的元素可以根据需要动态开辟内存单元。链表常被看作是与数组互补存在的一种数据构成方式。
1）链表的概念
在链表中，所有数据元素都被保存在一个据有相同数据结构的节点中，节点是链表的基本存储单位。一个节点与一个数据元素对应。每个节点在内存中使用一块连续的存储空间。把线性表的元素存放到一个由这种节点组成的链式存储中，每个节点之间可以占用不连续的内存空间，节点与节点之间通过指针链接在一起，这种存储方式叫做链表。
链表中每个节点至少由两个部分组成，即数据域和指针域。节点的定义需要采用结构类型，其一般形式为
struct node{
int data; //数据域
struct node *link;//指针域
} ;
在实际应用中，要建立一个链表通常包括三部分内容：
头指针，头节点，数据节点。
链表的存储空间可以在程序的运行期间动态分配，如果需要向链表中插入一个结点，只需调用C语言的动态空间分配函数（alloc，malloc函数）动态申请一个存储结点存放相应信息，并把新申请的结点插入到链表的适当位置上。删除一个结点意味着该结点被系统回收。C语言中free函数用来动态回收结点。
链表存储结构具有如下特点：
*插入、删除运算灵活方便，不需要移动结点，只需改变节点中指针域的值即可。
*可以实现动态分配和扩展空间，当表中数据是动态产生的时侯，最好使用链表。
*查找操作只能从链表的头结点开始顺序查找，不适合有大量频繁查找的表。
2）链表的基本操作
链表的基本操作有：建立链表、遍历链表、向链表中插入或删除结点、求链表长度等，这里仅介绍有关链表最基本的概念和相关操作。后续将会在数据结构的博客中详细介绍。
1.建立链表
建立链表首先要定义一个包含数据域和指针域的结构类型，然后定义一个指向表头结点的头指针，最后通过调用malloc函数动态申请结点的方法建立整个链表。
例子：程序中统计90分以上的成绩个数，当学号输入为零时将结束链表的建立。
1 #include<stdio.h>
2 #include<stdlib.h>
3 typedef struct student{
4 int num;
5 int score;
6 struct student *link;
7 } NODE;
8
9 NODE *creat(){
10 NODE *head=NULL,*p1=NULL,*p2=NULL;
11 head=p1=p2=(NODE *)malloc(sizeof(NODE));
12 printf("请输入学号和成绩:\n");
13 scanf("%d,%d",&p1->num,&p1->score);
14 p1->link=NULL;
15 while(p1->num!=0){
16 p1=(NODE *)malloc(sizeof(NODE));
17 p1->link=NULL;
18 printf("请输入学号和成绩:\n");
19 scanf("%d,%d",&p1->num,&p1->score);
20 p2->link=p1;
21 p2=p1;
22 }
23 return head;
24 }
25 int count(NODE *p){
26 int sum=0;
27 while(p!=NULL){
28 if(p->score>=90){
29 sum++;
30 }
31 p=p->link;
32 }
33 return sum;
34 }
35 int main(){
36 NODE *p;
37 p=creat();
38 printf("\n the count of 90 =%d\n",count(p));
39 return 0;
40 }
这里用一个头指针指向该链表，然后用两个指针变量的交替操作增加链表的长度，过程如下：
2.链表的遍历
所谓链表的遍历就是逐一访问链表中的每个结点：
设线性链表头指针为h，设指针变量p指向不同的结点。沿着链表开头向后查找结点中学号为x的结点。若找到则返回链表中该结点的位置，否则返回空地址。
NODE *search(NODE *L,int x){
NODE *p;
p=L->link;
while(p!=NULL&&p->num!=x){
p=p->link;
}
return (p);
}
3.链表的插入
要在单链表中的两个数据元素a和b之间插入一个数据元素x，首先将指针p指向结点a,然后生成一个新的结点，使其数据域为x，并使结点a中的link域指向新结点x,x的link域则指向结点b，即完成插入操作。
插入操作的程序如下：
void listInsert_L(NODE *L,int i,int x){
NODE *p=L,*s;
int j=0;
//寻找第i个结点
while(p&&j<i-1){
p=p->link;
++j;
}
//插入位置错误
if(!p||j>i-1){
return 0;
}
s=(NODE *)malloc(sizeof(NODE));
s->num=x;
s->link=p->link;
p->link=s;
return (1);
}
4.线性链表的删除
在a和b和c相邻的单链表中删除中间结点b的操作，只需将结点a的link域指向结点c,并释放接待你占用的存储空间即可。
单链表的删除操作的程序如下：
void ListDelete(NODE *L,int i,int,x){
NODE *p=L,*q;
int j=0;
while(p->link&&j<i-1){
p=p->link;
++p; //寻找第i个结点，并令p指向该前驱
}
if(!(p->link)||j>i-1) return (0);//删除位置错误
q=p->link; //删除并释放结点
p->link=q->link;
free(q);
return (1);
}
求链表长度
由于链表的长度不是预先确定，而是动态建立的，因此求链表的长度需要遍历链表的所有结点才能完成.
int Length(){
NODE *p=L;
int count=0;
while(p!=NULL){
count++;
p=p->link;
}
return (count);
}
链表实例:某班有20名学生，每名学生的数据包括学号、姓名、3门课的成绩，从键盘输入20名学生的数据，要求打印出3门课的总平均成绩，以及最高分的学生的数据。
1 #include<stdio.h>
2 #include<stdlib.h>
3 #include<time.h>
4 #include<string.h>
5
6 struct student{
7 long num;
8 char name[10];
9 int course[3];
10 int aver;
11 struct student *next;
12 };
13 typedef struct student NODE;
14
15 int main(){
16 srand(time(NULL));
17 NODE *head=NULL;
18 NODE *p1=NULL,*p2=NULL;
19 int i;
20 for(i=0;i<20;i++){
21 int j;
22 if(i==0){
23 head=p2=p1=(NODE *)malloc(sizeof(NODE));
24 }else{
25 p1=(NODE *)malloc(sizeof(NODE));
26 }
27 p1->num=14001+i;
28 int sum=0;
29 for(j=0;j<3;j++){
30 p1->course[j]=rand()%80+20;
31 }
32 for(j=0;j<3;j++){
33 sum+=p1->course[j];
34 }
35 p1->aver=sum/3;
36 char s[10];
37 itoa(i+1,s,10);
38 strcpy(p1->name,"student");
39 strcat(p1->name,s);
40 if(i!=0){
41 p2->next=p1;
42 p2=p1;
43 }
44 }
45 printf("下面打印出20名学生的信息:\n");
46 p1=head;
47 NODE *maxNode=head;
48 while(p1!=NULL){
49 if(maxNode->aver<p1->aver){
50 maxNode=p1;
51 }
52 printf("num=%ld,name=%9s,aver=%d\n",p1->num,p1->name,p1->aver);
53 p1=p1->next;
54 }
55 printf("平均分最高的学生信息为:\n");
56 printf("num=%d,name=%9s,course[0]=%d,course[2]=%d,course[3]=%d,aver=%d",
57 maxNode->num,maxNode->name,maxNode->course[0],maxNode->course[1],maxNode->course[2],maxNode->aver);
58 return 0;
59 }
值得注意的地方:
1.c语言中是没有string类型的，所以当用到字符串时都是用char类型的数组；
2.strcpy(s1,s2)是s2中内容加到s1上;
3.strcat(s1,s2)是将s2的内容加到s1的尾部;
4.itoa(a,str,10);将10进制整数转化为字符串后存到str中；
来源：https://www.cnblogs.com/MenAngel/p/5409856.html