c语言第八章 结构和联合

8.1结构1.结构：是拥有若干分量的一种构造类型，而且一个结构的分量可以有不同的类型，包括指针、数组、其它结构。2.定义：struct

结构类型名

{成员列表}；第八章结构和联合例:struct

date{unsignedyear;

unsignedmonth;unsignedday;};yearmonthday注:不带变量的结构说明不占存储空间，结构类型集中放到一个文件中，需要时用#include3.三种定义结构变量的方法1）先定义结构类型，再定义结构变量struct

date{unsignedyear;

unsignedmonth;

unsignedday;};struct

dated1,d2yearmonthdayd1yearmonthdayd22）在定义结构类型的同时定义变量struct

date{unsignedyear;

unsignedmonth;

unsignedday;}d1,d2;3）直接定义结构类型变量struct{unsignedyear;

unsignedmonth;

unsignedday;}date,d1,d2;3.三种定义结构变量的方法struct

student{intnum;

charname[20];

charsex;

intage;

struct

datebirthday;charaddr;}student1,student2;4.结构的嵌套struct

date{unsignedyear;unsignedmonth;unsignedday;};numnamesexagebirthdayyearmonthdayaddr8.2访问结构成员旧标准规定只能对结构变量中的成员分别访问，而不能对结构变量进行赋值和输出。新标准允许将一个结构变量直接赋给另一个具有相同结构的结构变量。如果结构变量本身又属于一个结构类型，只能对最低层的成员进行赋值、存取和运算。如：

student1.birthday.year=1967；“.”是成员（分量）运算符，优先级最高，自左向右结合。

结构成员可以象普通变量一样进行各种运算，例如：

student2.age=student1.age;

student1.age++;++studdent2.age;

可以引用成员的地址，结构变量的地址，例如：&

student1.num&student18.2访问结构成员当结构变量为全局变量或静态变量时，可在定义时初始化，例如：static

struct

student{intnum;

charname[20];charsex;charaddr[20];}a={54,“Jane”,“

M

”,“

123Road

”};8.2访问结构成员8.3结构数组和指向结构的指针当结构中的每一个元素都是同一结构类型时，称该数组为结构数组。定义结构数组时，可对全局或静态存储类别的数组初始化。structstudent{intnum;charname[20];

intage;charaddr[30];}stu[]={{10101,“LiLin”,18,“M”,“beijing”},

{10102,“FuPing”,19,“M”,“shanghai”}};numnamesexageaddr10101LiLinM18beijing10102FuPing19shanghaiMstustructstudent{intnum;charname[20];

intage;charaddr[30];}stu[]={{10101,“LiLin”,18,“M”,“beijing”},

{10102,“FuPing”,19,“M”,“shanghai”}};8.3结构数组和指向结构的指针struct

value{intkey；

intfreq；}；#defineARRAYSIZE1000；staticstruct

valueset_arr[ARRAYSIZE]；find(x)intx{inti,m；set_arr[m=set_arr[0].freq+1].key=x；set-arr[m].freq=0；for(i=1；set-arr[i].key!=x；i++)；set-arr[i].freq++；if(i==m)set-arr[0].freq++;}例8.1在某集合中查询是否存在值x，若不存在，则将x加入集合中。每次查询均记录查询的频率。keyfreqset-arr[0]set-arr[i]set-arr[m]x0

x

freq++字符个数指向结构的指针：用一个指针变量指向结构变量，此时该指针变量的值是结构变量的起始地址。指针变量也可以用来指向结构数组中的元素。例如：

struct

studentstu_1;

/*定义结构变量*/struct

student

stu［4］;/*定义结构数组*/struct

student

*p;

/*定义指向结构的指针变量*/p=&stu_1;

/*指向结构变量stu_1*/p=stu;

/*指向结构数组stu*/8.3结构数组和指向结构的指针structstudent{intnum;charname［20］;charsex;floatscore;};通过指向结构的指针访问结构成员，访问结构成员的方式：结构变量名.成员名例如：stu_1.num；(*p).num；/*(*p)表示p指向的结构变量，注意*p两侧的括号不能省略，因为成员运算符的优先级高于取内容运算符的优先级。(*p).num:p指向的结构变量中的成员num。通过指针变量访问结构成员的一般形式是:指向结构的指针变量->成员名注意“.”和“->”的优先级相同，自左向右结合。例如：p->num；stu_1.num；(*p)

.num；含义相同。8.3结构数组和指向结构的指针请分析以下几种运算：p->n；得到p指向的结构变量中成员n的值。

p->n++；得到p指向的结构变量中的成员n的值，用完该值后使它加1。++p->n；得到p指向的结构变量中的成员n的值使之加1。如果p指向结构数组的某个元素，那么，(++p)->num；取下一个数组元素的成员num的值。(p++)->num取数组元素的成员num的值，然后将p指向下一个数组元素。(

)(

)如果指针p已定义为指向struct

student类型的数据，它只能指向一个结构类型数据。p的值是stu数组的一个元素的起始地址。不是指向一个数组元素中的某一成员，即p的地址不能是成员的地址。例如：p=&stu［2］.num；/*是不对的*/8.3结构数组和指向结构的指针

例8.2在UNIX系统中用结构数组sptmap来记录系统页表空间。可以这样简单理解：数组sptmap的每一个元素记录一片连续的可用空间，其成员分别表示可用空间的首地址和长度，结构如下：struct

map{shortm_size;/*长度*/

unsignedshortm_addr;/*地址*/}sptmap［100］;从sptmap[1]开始搜索sptmap，sptmap[0].m-addr=0sptmap[0].m-size=整个stpmap表中未用的map数，初始化时将未用表项的成员m-size置0。8.3结构数组和指向结构的指针m-addrm-sizesptmap[100]0表中未用的map数0102401023102420472048304730485047504810242048100030482000#definemapstart(x)&x[1]#definemapsize(x)x[0].m-sizemalloc(mp,size)structmap*mp;unsignedsize;{registerunsignedinta;registerstructmap*bp;for(bp=mapstart(mp);bp->m-size;bp++){if(bp->m-size>=size){a=bp->m-addr;

bp->m-addr+=size;

if((bp->m-size-=size)==0){do{bp++;

(bp-1)->m-addr=bp->m-addr;

}while((bp-1)->m-size=bp->m-size);

mapsize(mp)++;}

return(a);}}return(0);}1.sizeof()：“求字节数”运算符，其优先级别与++、--等运算符相同。sizeof的运算对象：数据类型，返回值：该类型数据在内存中占用的字节数量。例如：sizeof(int),

sizeof(double*),

sizeof(structstudent)等等。2.malloc函数：以一个无符号整数作为参数，返回指向字符的指针，例如：char*p;p=malloc(10);从可用空间中分配连续10个字节的存储空间，返回该片存储空间的首地址。如果没有足够的可用空间，则返回一个空指针NULL用以表明分配空间失败。8.4sizeof运算符和Ｃ的动态存储分配函数3.free(p)：p是一个指针，free将p所指向的存储空间归还给系统。执行free(p)后，不会变更指针变量p的值，这个指针仍然指向原来的存储空间。若p和q是两个指向同一地址的指针变量，则执行free(p);后，应该跟有如下语句：

p=q=NULL；例如：int*pi；char*pc；语句*pc=‘a’；是错误的。因为pc的初值不确定。可以把某个变量的地址赋给pc，或用malloc函数为它动态地分配存储空间：pc=malloc(1)；为安全起见，调用malloc时应该判断是否成功地分配了存储空间。形式如下：if((pc=malloc(1))==NULL)假设调用malloc分配了位置是10的一个存储单元，则语句*pc=‘a’；8.4sizeof运算符和Ｃ的动态存储分配函数#include“stdio.h”#defineINTSIZEsizeof(int)#defineNODESIZEsizeof(int)+sizeof(char*)#defineERROR{printf(“error\n”);return;}main(){inti;char*p,*q,*first,*malloc();

if((p=malloc(NODESIZE))==NULL)ERROR

first=p;*(int*)p=1;p+=INTSIZE;for(i=2;i<10;i++,p+=INTSIZE)

if((q=malloc(NODESIZE))==NULL)ERROR

else{*(char**)p=q;p=q;*(int*)p=i;}*p=NULL;for(p=first;p;p+=INTSIZE,p=*(char**)p)

printf(“%d”,*(int*)p);putchar(‘\n’);}例8.3建立一个从1到9的整数链表，然后打印出这些值。P=malloc(sizeof(int)+sizeof(char*))*(int*)p=1p+=sizeof(int)*(char**)p=(q=malloc(sizeof(int)+sizeof(char*)))****(int*)p=2p+=sizeof(int)*(int*)p=8p+=sizeof(int)*(char**)p=(q=malloc(sizeof(int)+sizeof(char*)))****(int*)p=9NULL函数之间结构体变量的数据传递向函数传递结构体变量的成员作为成员变量（简单变量、数组或指针变量），它们可以参与所属类型允许的任何操作；向函数传递结构体变量新的ANSIC标准允许把结构体变量作为一个整体传送给相应的形参；传递的是实参结构体变量的值；系统将为结构体类型的形参开辟相应的存储单元，并将实参中各成员的值赋给对应的形参成员。8.5结构作为函数的参数结构体变量作为实参传递给函数，对应形参得到的是它的值；函数体内对形参结构体变量中任何成员的操作，都不会影响对应实参中成员的值；保证了调用函数中数据的安全；限制了将运算结果返回给调用函数。8.5结构作为函数的参数8.5结构作为函数的参数在旧标准中，在结构上可以执行的操作仅有用&来取得它的地址，和引用它的成员。指向结构的指针变量却不受这些限制，从而使结构和函数仍能在一起协调工作。函数的返回值是结构体类型；函数可以返回指向结构的指针；用指向结构的指针变量作参数。传递结构体的地址：将结构体变量的地址作为实参传递对应的形参应该是一个基类型相同的结构体类型指针；系统只需为形参指针开辟一个存储单元存放实参结构体变量的地址值，而不必另行建立一个结构体变量；通过函数调用，有效地修改结构体中成员的值节省时间、提高效率。8.5结构作为函数的参数例：通过函数给结构体成员赋值structst{chars[10];

intt;}getdata(struct

st

*p){scanf(“%s%d”,p->s,&p->t);}main(){struct

st

a;

getdata(&a);

printf(“%s,%d\n”,a.s,a.t);}8.5结构作为函数的参数函数的返回值是结构体类型，例：struct

st

{inta;charb;}structstfun(struct

st

x){x.a=99;x.b=‘S’;returnx;}main(){struct

st

y;y.a=0;y.b=‘A’;

printf(“y.a=%dy.b=%c\n”,y.a,y.b);

y=fun(y);

printf(“y.a=%dy.b=%c\n”,y.a,y.b);}8.5结构作为函数的参数运行结果：y.a=0y.b=Ay.a=99y.b=S函数的返回值可以是指向结构体变量的指针，例：struct

st

{inta;charb;}structst

*fun(struct

st

x){struct

st

*px

x.a=100;x.b=‘C’;px=&x;returnpx;}main(){struct

st

y,*p;

y.a=999;y.b=‘X’;printf(“y.a=%dy.b=%c\n”,y.a,y.b);

p=fun(y);printf(“(*p).a=%d(*p).b=%c\n”,(*p).a,p->b);}8.5结构作为函数的参数运行结果：y.a=999y.b=X(*p).a=100(*p).b=C例如：structstudent{longnum;charname[20];};一个返回结构指针的函数

structstudent*new(){structstudent*aux;aux=(structstudent*)malloc(sizeof(structstudent));if(aux==NULL)

printf(“Outofmemory\n”);return(aux);}8.5结构作为函数的参数也可以把此函数写成传递一个指向结构的指针的指针作参数的函数。

voidnew1(s)

struct

student**s;{struct

student*aux;

aux=(struct

student*)malloc(sizeof(struct

student));if(aux==NULL)

printf(“Outofmemory\n”);else*s=aux;}8.5结构作为函数的参数利用结构体变量构成链表结构体中含有可以指向本结构体的指针成员结构体的自引用：当一个结构体中有一个或多个成员是指针，它们的基类型就是本结构体类型时，通常把这种结构体称为可以“引用自身的结构体”。例如：struct

link{charch;

struct

link

*p;}a;8.6结构的自引用a.ch

a.p

链表：把同一类型的结构体变量“链接”到一起形成“链表”；结点：被连接在一起的结构体变量；静态链表：由系统在内存中开辟了固定的、互不连续的存储单元，在程序执行的过程中，不可能人为地再产生新的存储单元，也不可能人为地使已开辟的存储单元消失。8.6结构的自引用0f04100f0C200f1430NULL0f000f020f040f060f080f0A0f0C0f0E0f100f120f140f16ha.cha.pb.chb.pc.chc.p例：一个简单的链表struct

node{intdata;

struct

node

*next;}main(){structnodea,b,c,*h,*p;a.data=10;b.data=20;c.data=30;

h=&a;a.next=&b;b.next=&c;c.next=‘\0’;

p=h;while(p){printf(“%d”,p->data);

p=p->next;}

printf(“\n”);}8.6结构的自引用abc102030h\0ppp动态链表：链表中的每个存储单元都由动态存储分配函数获得。各次动态分配的存储单元地址不连续；各数据之间存在着接序关系；每个结点由数据域和指针域组成指针域：存放下一个结点元素的地址每个结点元素没有自己的名字，只能由指针维系结点元素之间的接序关系；一旦某个元素的指针“断开”，后续元素就再也无法找寻。8.6结构的自引用头指针：指向链表的开始；头结点：该结点的数据域中不存放数据；尾结点：链表最后一个结点的指针域置成‘\0’，标志链表的结束；每个结点的指针域存放下一结点的地址；单向链表：只能从当前结点找到后继结点。链表的建立、结点数据域的输出、结点的插入和删除。8.6结构的自引用头结点87头指针\09建立带有头结点的单向链表读取数据生成新结点将数据存入结点的成员变量中将新结点插入到链表中8.6结构的自引用头结点87头指针\09struct

*create_slist1(){intc;

structslist

*h,*s,*r;

h=(structslist)malloc(sizeof(structslist));

r=h;

scanf(“%d”,&c);while(c!=-1){s=(structslist)malloc(sizeof(structslist));

s->data=c;r->next=s;r=s;

scanf(“%d”,&c);}

r->next=‘\0’;returnh;}main(){

structslist

*head;······

head=create_slist1();······}8.6结构的自引用structslist{intdata;

structslist

*next;}顺序访问链表中各结点的数据域工作指针p：从头到尾依次指向链表中的每个结点当指针指向某个结点时，就输出该结点数据域中的内容；直到遇到链表结束标志为止；如果是空链表，只输出有关信息并返回调用函数。8.6结构的自引用voidprint_slist(structslist

*head){

structslist

*p;

p=head->next;if(p==‘\0’)printf(“Linklistisnull!\n”);else{printf(“head”);do{printf(“->%d”,p->data);

p=p->next;}while(p!=‘\0’);

printf(“->end\n”);}}8.6结构的自引用structslist{intdata;

structslist

*next;}头结点87头指针\09在单向链表中插入结点确定插入的位置后插：当插入结点插在指针p所指的结点之后；前插：当插入结点插在指针p所指的结点之前，当进行前插操作时，需要三个工作指针；s：指向新开辟的结点；p：指向插入的位置；q：指向p的前趋结点。8.6结构的自引用s879pq例：编写函数insert_snode，在值为x的结点前插入值为y的结点，若值为x的结点不存在，则插在表尾。在进行插入的过程中，可能遇到三种情况：链表非空，值为x的结点存在，新结点应插在该结点之前；链表非空，但值为x

的结点不存在，按要求，新结点应插在链表的结尾；链表为空表，这种情况相当于值为x

的结点不存在，新结点应插在链表的结尾，即插在头结点之后，作为链表的第一个结点；8.6结构的自引用insert_snode(structslist*head,intx,inty){structslist*s,*p,*q;s=(structslist*)malloc(sizeof(structslist));s->data=y;q=head;p=head->next;while((p!=‘\0’)&&(p->data!=x)){q=p;p=p->next;}s->next=p;q->next=s;}8.6结构的自引用structslist{intdata;

structslist

*next;}删除单向链表中的结点找到待删除结点的前趋结点q；将此前趋结点的指针域指向待删除结点的后续结点；释放被删结点所占存储空间。8.6结构的自引用头指针h头结点78p9q8.6结构的自引用二叉树的数据结构的实现。二叉树中每个结点记录一个不同的单词，结点内容如下：指向该单词内容的指针该单词出现的次数指向左孩子结点的指针指向右孩子结点的指针定义结点的结构：

structtnode

{char*word;

intcount;

struct

tnode

*left;

struct

tnode

*right;};这就是结构的自引用。left和right是指向结构的指针，而不是一个结点。*left*right*wordcounttnode8.6结构的自引用若输入如下单词：C++、Java、Fortran、basic、Foxbase、C++，二叉树的生成过程如下：*left*rightC++count*left*rightBasiccount*left*rightFoxbasecountCount=2*left*rightJavacount*left*rightFortrancount8.6结构的自引用#defineMAXWORD20main(){

struct

tnode

*root,*tree();

char*t;

root=NULL;while((t=getword())!=NULL)

root=tree(root,t);

treeprint(root);}char*getword(){char*p;if((p=malloc(MAXWORD+1))==NULL)

{printf(“Outofmemory\n”);return(NULL);}

scanf(“%MAXWORDs”,p);

if(strlen(p)==0)return(NULL);

return(p);}8.6结构的自引用struct

tnode

*tree(p,w)structtnode

*p;char*w;{struct

tnode

*talloc();

intcond;if(p==NULL){p=talloc();p->word=w;p->count=1;p->left=p->right=NULL;}elseif((cond=strcmp(w,p->word))==0)p->count++;elseif(cond<0)p->left=tree(p->left,w);else8.6结构的自引用

p->right=tree(p->right,w);return(p);}treeprint(p)struct

tnode

*p;{if(p!=NULL){treeprint(p->left);

printf(“%4d%s＼n”,p->count,p->word);

treeprint(p->right);}}struct

tnode

*talloc(){return((struct

tnode*)malloc(sizeof(struct

tnode)));}8.6结构的自引用8.7位域—存储空间的充分利用为了节省存储空间，往往需要把几个对象挤进一个机器字去。例如：

struct

packed-data{unsigneda:2;

unsignedb:6;

unsignedc:4;unsignedd:4;

inti;}data;struct

packed-data{unsigneda:2;

unsignedb:3;

unsignedc:4;inti;}data;1.若某一位域要从另一个字开始存放，可以用以下形式定义：unsigneda:1;unsignedb:2;

一个储存单元unsigned:0;unsignedc:3;（另一个单元）本来a,b,c应连续存放在一个存储单元（字）中，由于使用了长度为0的位域，其作用是使下一个位域从下一个存储单元开始存放。因此a,b存储在一个存储单元中，而将c存放在另一个存储单元中。8.7位域—存储空间的充分利用2.一个位域必须存储在同一存储单元中，不能跨两个单元。如果第一个存储单元所剩空间不能容纳下一个位域，则该空间不用，而从下一个单元起存放该位域。3.可以定义无名位域。如：unsigneda:1;unsigned:2;（两个空间不用）unsignedb:3;unsignedc:4;4.位域的长度不能大于存储单元的长度，也不能定义位域数组。8.7位域—存储空间的充分利用5.位域可以用整型格式输出。如：printf(“%d,%d,%d”,data.a,data.b,data.c);6.位域可以在数值表达式中引用，它会被系统自动地转换成整型数。如：data.a+5/data.b8.7位域—存储空间的充分利用8.8联合（共用体）联合:可以让几种不同类型的变量存放到同一段内存单元中。是一种类似于结构的复合类型。任一时刻只能有一个变量起作用。联合类型变量的定义形式是：union

联合类型名{成员列表}变量名列表；这里变量a,b,c的存储空间:uniondata{inti;

charch;

floatf;}a,b,c;uniondata{inti;charch;floatf;};union

dataa,b,c;8.8联合0f03a.ch0f030f02a.i0f030f020f010f00a.f当编译程序看到关键字union时，就会为联合中最长的成员项保留一个足够大的空间。联合通常用于保存函数调用的返回值，以便于为程序的其它部分按不同的数据类型引用值。联合变量的引用方式先定义了联合变量才能引用它，而且不能引用联合变量，只能引用联合变量中的成员。8.8联合union

u-tag{intival;floatfval;char*pval;}uval;成员引用时可用uval.ival、uval.fval联合可以出现在结构和数组中,反之亦然8.8联合例如:struct{char*name;

intflags;

intutype;

union{intival;floatfval;char*pval;}uval;}symtab［NSYM］;

*symtab[i].uval.pval8.8联合联合的特点同一个内存段可用来存放几种不同类型的成员，但在每一瞬间只能存放其中一种，即每个瞬间只有一个成员起作用，其它成员不起作用。联合中起作用的是最后一次存放的成员。联合变量的地址和它的各成员的地址相同。不能在定义联合变量的同时对其进行初始化。不能把联合变量作为函数的参数，也不能使函数带回联合变量，但可以使用指向联合变量的指针。使用联合比使用结构更能节省存储空间，但其代价是访问成员的速度要慢一些。8.8联合例：利用共同体的特点分别取出int变量中高字节和低字节中的两个数。unionchange{charc[2];

inta;}un;main(){un.a=16961;

printf(“%d,%c\n”,un.c[0],un.c[0]);

printf(“%d,%c\n”,un.c[1],un.c[1]);}8.8联合un.c[1]un.c[0]01000010010000100f010f02un.a66,B65,A例8.4从键盘上读10个值，每个值从一新行开始读起，以字符I或C开头，指出此值是整数还是字符。把这些值保存在链表中，重新显示。#include“stdio.h”#defineINTEGER‘I’#defineCHARACTER‘C’#defineERROR{printf(“Error\n”);return;}#defineSKIPwhile(getchar()!=‘\n’);8.8联合main(){inti;

structitem{union{charc;

inti;}val;

intwhat;

structitem*next;}*p,*temp;if((p=(structitem*)malloc(sizeof(structitem))==NULL)ERRORtemp=p;for(i=0;;i++){switch(getchar()){caseINTEGER:p->what=0;

scanf(“%d”,&(p->vali));break;caseCHARACTER:p->what=1;

scanf(“%c”,&(p->valc));break;default:ERROR}SKIPif(i==9)break;else{if((p->next=(structitem*)malloc(sizeof(structitem)))==NULL)ERRORp=p->next;}}for(i=0,p=temp;i<10;p=p->next,i++)if(p->what)

printf(“%c”,p->valc);elseprintf(“%d”,p->vali);}8.9枚举类型枚举类型是ANSIＣ新标准所增加的。枚举：将变量的可能取值一一列举出来，变量的值只限于列举出来的值的范围。定义枚举类型用关键字enum开头。例如：enum

weekday{sun,mon,tue,wed,thu,fri,sat};enum

weekdayworkday,week-end;weekday和week-end被定义为枚举类型变量，它们的值只能是sun到sat之一。例如：workday=mon;

或week-end=sun;在Ｃ语言编译中，将枚举元素按常量处理。它们不是变量，不能对它们赋值。枚举元素作为常量，它们是有值的。Ｃ语言编译时按定义的顺序使它们的值为0，1，2,…,n在上面定义中，sun的值是0，mon的值为1，sat为6。

workday=mon;

printf(“%d”,workday);将输出整数1。8.9枚举类型也可以在定义时由程序员指定枚举元素的值，如：

enum

weekday{sun=7,mon=1,tue,wed,thu,fri,sat};枚举值可以进行比较运算。其比较规则是：按其在定义时的顺序号比较。如果定义时没有人为指定序号，则第一个枚举元素值认作0。一个整数不能直接赋给一个枚举变量。但可以通过强制类型转换赋值。如：workday=(enum

weekday)2;8.9枚举类型8.10typedef定义类型Ｃ语言中可以用typedef来定义一个新的类型名。例如：

typedefintLENGTH;LENGTHlen,maxlen;LENGTH*lengths[];同样，说明typedefchar*STRING;STRINGp,lineptr[LINES];也可以定义结构类型：typedef

struct{

intmonth;

intday;

intyear;}DATE;用typedef来定义的类型名总是用大写字母书写的。一个更复杂的例子:为本章中的树结点写出类型定义:typedef

structtnode{char*word;

intcount;

structtnode*left;

structtnode*right;}TREENODE,*TREEPTR;#define是在预编译时处理的，它只能做简单的字符串替换，而typedef是在编译时处理的。实际上它并不是做简单的字符串替换。8.10typedef定义类型使用typedef有两个主要的理由：有利于程序移植。如果把typedef用于可能与机器有关的数据类型，则在程序移植时仅需改变typedef,从而减少大量的程序修改工作。使用typedef能为程序提供更多的可读信息，用一个适当的符号名表示一个复杂的结构类型会增强程序的可读性。8.10typedef定义类型写一个函数建立一个有5名学生数据的单向链表structstudent{longnum;floatscore;

structstudent

*next;};#defineLENsizeof(st