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