|
|
1. 基本解釋
typedef為C語(yǔ)言的關(guān)鍵字，作用是為一種數(shù)據(jù)類型定義一個(gè)新名字。這里的數(shù)據(jù)類型包括內(nèi)部數(shù)據(jù)類型（int,char等）和自定義的數(shù)據(jù)類型（struct等）。
在編程中使用typedef目的一般有兩個(gè)，一個(gè)是給變量一個(gè)易記且意義明確的新名字，另一個(gè)是簡(jiǎn)化一些比較復(fù)雜的類型聲明。
至于typedef有什么微妙之處，請(qǐng)你接著看下面對(duì)幾個(gè)問題的具體闡述。
2. typedef & 結(jié)構(gòu)的問題
當(dāng)用下面的代碼定義一個(gè)結(jié)構(gòu)時(shí)，編譯器報(bào)了一個(gè)錯(cuò)誤，為什么呢？莫非C語(yǔ)言不允許在結(jié)構(gòu)中包含指向它自己的指針嗎？請(qǐng)你先猜想一下，然后看下文說明：
typedef struct tagNode
{
char *pItem;
pNode pNext;
} *pNode;
答案與分析：
1、typedef的最簡(jiǎn)單使用
typedef long byte_4;
給已知數(shù)據(jù)類型long起個(gè)新名字，叫byte_4。
2、 typedef與結(jié)構(gòu)結(jié)合使用
typedef struct tagMyStruct
{
int iNum;
long lLength;
} MyStruct;
這語(yǔ)句實(shí)際上完成兩個(gè)操作：
1) 定義一個(gè)新的結(jié)構(gòu)類型
struct tagMyStruct
{
int iNum;
long lLength;
};
分析：tagMyStruct稱為“tag”，即“標(biāo)簽”，實(shí)際上是一個(gè)臨時(shí)名字，struct 關(guān)鍵字和tagMyStruct一起，構(gòu)成了這個(gè)結(jié)構(gòu)類型，不論是否有typedef，這個(gè)結(jié)構(gòu)都存在。
我們可以用struct tagMyStruct varName來定義變量，但要注意，使用tagMyStruct varName來定義變量是不對(duì)的，因?yàn)閟truct 和tagMyStruct合在一起才能表示一個(gè)結(jié)構(gòu)類型。
2) typedef為這個(gè)新的結(jié)構(gòu)起了一個(gè)名字，叫MyStruct。
typedef struct tagMyStruct MyStruct;
因此，MyStruct實(shí)際上相當(dāng)于struct tagMyStruct，我們可以使用MyStruct varName來定義變量。
答案與分析
C語(yǔ)言當(dāng)然允許在結(jié)構(gòu)中包含指向它自己的指針，我們可以在建立鏈表等數(shù)據(jù)結(jié)構(gòu)的實(shí)現(xiàn)上看到無數(shù)這樣的例子，上述代碼的根本問題在于typedef的應(yīng)用。
根據(jù)我們上面的闡述可以知道：新結(jié)構(gòu)建立的過程中遇到了pNext域的聲明，類型是pNode，要知道pNode表示的是類型的新名字，那么在類型本身還沒有建立完成的時(shí)候，這個(gè)類型的新名字也還不存在，也就是說這個(gè)時(shí)候編譯器根本不認(rèn)識(shí)pNode。
解決這個(gè)問題的方法有多種：
1)、
typedef struct tagNode
{
char *pItem;
struct tagNode *pNext;
} *pNode;
2)、
typedef struct tagNode *pNode;
struct tagNode
{
char *pItem;
pNode pNext;
};
注意：在這個(gè)例子中，你用typedef給一個(gè)還未完全聲明的類型起新名字。C語(yǔ)言編譯器支持這種做法。
3)、規(guī)范做法：
struct tagNode
{
char *pItem;
struct tagNode *pNext;
};
typedef struct tagNode *pNode;
3. typedef & #define的問題
有下面兩種定義pStr數(shù)據(jù)類型的方法，兩者有什么不同？哪一種更好一點(diǎn)？
typedef char *pStr;
#define pStr char *;
答案與分析：
通常講，typedef要比#define要好，特別是在有指針的場(chǎng)合。請(qǐng)看例子：
typedef char *pStr1;
#define pStr2 char *;
pStr1 s1, s2;
pStr2 s3, s4;
在上述的變量定義中，s1、s2、s3都被定義為char *，而s4則定義成了char，不是我們所預(yù)期的指針變量，根本原因就在于#define只是簡(jiǎn)單的字符串替換而typedef則是為一個(gè)類型起新名字。
#define用法例子：
#define f(x) x*x
main( )
{
int a=6，b=2，c；
c=f(a) / f(b)；
printf("%d "，c)；
}
以下程序的輸出結(jié)果是: 36。
因?yàn)槿绱嗽颍谠S多C語(yǔ)言編程規(guī)范中提到使用#define定義時(shí)，如果定義中包含表達(dá)式，必須使用括號(hào)，則上述定義應(yīng)該如下定義才對(duì)：
#define f(x) (x*x)
當(dāng)然，如果你使用typedef就沒有這樣的問題。
4. typedef & #define的另一例
下面的代碼中編譯器會(huì)報(bào)一個(gè)錯(cuò)誤，你知道是哪個(gè)語(yǔ)句錯(cuò)了嗎？
typedef char * pStr;
char string[4] = "abc";
const char *p1 = string;
const pStr p2 = string;
p1++;
p2++;
答案與分析：
是p2++出錯(cuò)了。這個(gè)問題再一次提醒我們：typedef和#define不同，它不是簡(jiǎn)單的文本替換。上述代碼中const pStr p2并不等于const char * p2。const pStr p2和const long x本質(zhì)上沒有區(qū)別，都是對(duì)變量進(jìn)行只讀限制，只不過此處變量p2的數(shù)據(jù)類型是我們自己定義的而不是系統(tǒng)固有類型而已。因此，const pStr p2的含義是：限定數(shù)據(jù)類型為char *的變量p2為只讀，因此p2++錯(cuò)誤。
（注：關(guān)于const的限定內(nèi)容問題，在本系列第二篇有詳細(xì)講解）。
#define與typedef引申談
1) #define宏定義有一個(gè)特別的長(zhǎng)處：可以使用 #ifdef ,#ifndef等來進(jìn)行邏輯判斷，還可以使用#undef來取消定義。
2) typedef也有一個(gè)特別的長(zhǎng)處：它符合范圍規(guī)則，使用typedef定義的變量類型其作用范圍限制在所定義的函數(shù)或者文件內(nèi)（取決于此變量定義的位置），而宏定義則沒有這種特性。
5. typedef & 復(fù)雜的變量聲明
在編程實(shí)踐中，尤其是看別人代碼的時(shí)候，常常會(huì)遇到比較復(fù)雜的變量聲明,使用typedef作簡(jiǎn)化自有其價(jià)值，比如：
下面是三個(gè)變量的聲明，我想使用typdef分別給它們定義一個(gè)別名，請(qǐng)問該如何做？
>1：int *(*a[5])(int, char*);
>2：void (*b[10]) (void (*)());
>3. doube(*)() (*pa)[9];
答案與分析：
對(duì)復(fù)雜變量建立一個(gè)類型別名的方法很簡(jiǎn)單，你只要在傳統(tǒng)的變量聲明表達(dá)式里用類型名替代變量名，然后把關(guān)鍵字typedef加在該語(yǔ)句的開頭就行了。
（注：如果你對(duì)有些變量的聲明語(yǔ)法感到難以理解，請(qǐng)參閱本系列第十篇的相關(guān)內(nèi)容）。
>1：int *(*a[5])(int, char*);
//pFun是我們建的一個(gè)類型別名
typedef int *(*pFun)(int, char*);
//使用定義的新類型來聲明對(duì)象，等價(jià)于int* (*a[5])(int, char*);
pFun a[5];
>2：void (*b[10]) (void (*)());
//首先為上面表達(dá)式藍(lán)色部分聲明一個(gè)新類型
typedef void (*pFunParam)();
//整體聲明一個(gè)新類型
typedef void (*pFun)(pFunParam);
//使用定義的新類型來聲明對(duì)象，等價(jià)于void (*b[10]) (void (*)());
pFun b[10];
>3. doube(*)() (*pa)[9];
//首先為上面表達(dá)式藍(lán)色部分聲明一個(gè)新類型
typedef double(*pFun)();
//整體聲明一個(gè)新類型
typedef pFun (*pFunParam)[9];
//使用定義的新類型來聲明對(duì)象，等價(jià)于doube(*)() (*pa)[9];
pFunParam pa;
//第1篇:typedef語(yǔ)句格式
#include
typedef int GTYPE;//定義全局類型GTYPE
void main()
{
//一、基本格式
typedef char CH;//重定義基本類型
typedef struct{int a,b,c;}STRU;//重定義自定義類型(結(jié)構(gòu)、共用、枚舉)
typedef union{int a,b,c;}UNIO;
typedef enum{one,two,three}NUM;
typedef char* STR;//重定義派生類型(指針、數(shù)組、函數(shù))
typedef int AI[10];
typedef void FUN(void);
//可見，typedef使用的格式為：typedef 變量/函數(shù)定義語(yǔ)句；即在原變量/函數(shù)定義語(yǔ)句的開頭加上
//typedef，便可將原變量/函數(shù)定義語(yǔ)句改寫為類型定義語(yǔ)句，原來定義的變量名/函數(shù)名都成了類型名。
//注：當(dāng)重定義基本、自定義類型時(shí)，格式也可總結(jié)為：typedef 原類型 新類型1,新類型2,…；
//二、觀察原類型
//1.原類型可以帶有類型限定符
typedef const int CI;//原類型含const限定符
CI ci=3;
//ci=4;//可見CI確實(shí)代表const int
//2.原類型可以是typedef定義的新類型
typedef CH NEWCH;//CH已在前面定義為char
NEWCH nc='a';
//3.原類型不可帶有存儲(chǔ)類別
//typedef static int SI;//錯(cuò)誤，"指定的存儲(chǔ)類多于1個(gè)"
//typedef register int RI;//錯(cuò)誤同上
//4.原類型應(yīng)是一種類型，而不可是變量/對(duì)象
float f=0;//將f定義為變量
//typedef f FL;//錯(cuò)誤
//5.不宜重定義的類型
typedef const CON;//重定義const
//CON int a=0;//但該類型無法正常使用
typedef unsigned US;//重定義unsigned
US us1=0;//正確，相當(dāng)于unsigned int
//US int us2;//錯(cuò)誤，無法正常使用
//注：因const、unsigned等并不是一種獨(dú)立的類型，故不便對(duì)它們重定義
//三、觀察新類型
//1.新類型的作用域
typedef int LTYPE;//定義局部類型LTYPE
void fun();//觀察LTYPE在fun中是否有效
fun();
//可見，用typedef定義的類型也有作用域之分。在函數(shù)內(nèi)用typedef定義的是局部類型
//typedef也可以像變量定義語(yǔ)句一樣放置在函數(shù)之外，這時(shí)定義的是全局類型
//2.新類型可否是已有類型
//typedef int float;//錯(cuò)誤，不能重定義標(biāo)準(zhǔn)類型
typedef int TYPE; //定義了新類型TYPE
//typedef char TYPE;//錯(cuò)誤，"TYPE重定義"
typedef int GTYPE;//正確，盡管GTYPE是已有類型，但它是本函數(shù)外定義的
//可見，新類型名必須是合法的標(biāo)識(shí)符，它在其作用域內(nèi)必須是唯一的
//3.新類型可否不止一個(gè)
typedef float LENGTH,WIDTH;//對(duì)float取兩個(gè)別名，LENGTH和WIDTH
LENGTH L=0;//用新類型定義變量
WIDTH W=0;
//可見，可以一次性為某個(gè)原類型指定多個(gè)別名
//4.一次可否定義多個(gè)不同類型
//typedef int I,float F;//一次定義了二個(gè)不同類型I和F
//F v=6.0;//試圖使用F類型
//printf("v=%f ",v);//v=0,類型F無效
//可見，一條typedef語(yǔ)句只宜為一個(gè)原類型定義別名
}
void fun()
{ //LTYPE i;//錯(cuò)誤，"LTYPE:未定義的標(biāo)識(shí)符"
GTYPE g=1;//使用全局類型GTYPE
printf("g=%d ",g);//正常使用
}
//第2篇:typedef詳細(xì)使用
/* 為了從易到難地使用typedef，現(xiàn)將C++數(shù)據(jù)類型按照類型名的來源和復(fù)雜性重分類如下：
一、基本類型（類型名是系統(tǒng)指定的單一標(biāo)識(shí)符）
in,char,float,double,void,const
二、自定義類型（類型名是用戶定義的單一標(biāo)識(shí)符）
1.結(jié)構(gòu)類型
struct stru{int i;struct stru*;};
2.共用類型
union unio{int i;enum num[10];};
3.枚舉類型
enum num{a,b,c};
4.typedef類型
typedef double db;
三、派生類型（類型名由已有類型與其它符號(hào)組合而成）
1.指針類型（由 已有類型* 組成）
void*,char**,void(*)(),struct stru*,enum num*
2.數(shù)組類型（由 已有類型[][] 組成）
int[3][4],struct stru[10],enum num[10],char*[10]
3.函數(shù)類型（類型名是各種符號(hào)組成的函數(shù)原型）
void main(void),char* strcpy(char*,char*)
以上三大類別的類型標(biāo)識(shí)符由簡(jiǎn)單到復(fù)雜，學(xué)習(xí)typedef時(shí)要依照先后順序，練習(xí)每種類型的重定義
每定義出一種新類型后，從以下幾個(gè)方面使用它：用它定義變量、指針、數(shù)組、帶存儲(chǔ)類別的對(duì)象、
帶const的對(duì)象；用它作函數(shù)參數(shù)和返回值類型；用它進(jìn)行類型轉(zhuǎn)換；用sizeof求長(zhǎng)度*/
#include
#include
void main()
{
//一、重定義基本類型
//1.定義
typedef int in;
typedef char ch;
typedef float fl;
typedef double db;
typedef unsigned int ui;//或?qū)憺閠ypedef unsigned ui;
typedef unsigned char uc;
typedef void vo;
//2.使用
in i=3;printf("i=%d ",i); //用新類型定義變量
ch* pc="pc";printf("pc=%s ",pc);//用新類型定義指針
fl af[3]={1,2,3};printf("af[0]=%f ",af[0]);//用新類型定義數(shù)組
static double sd;printf("sd=%f ",sd);//用新類型定義帶存儲(chǔ)類別的變量
const ui cui=3;printf("cui=%d ",cui);//用新類型定義帶類型限定符的變量
vo fun1(uc);fun1('a');//用新類型作函數(shù)的參數(shù)和返回值類型
printf("in(1.5)=%d ",in(1.5));//將新類型用作類型轉(zhuǎn)換
printf("$db=%d ",sizeof(db));//對(duì)新類型求長(zhǎng)度，$db=$double=8
//二、重定義自定義類型
//1.定義
//(1)完整寫法(先定義好自定義類型，再重定義它)
struct datetype //重定義結(jié)構(gòu)類型
{ ui year;//ui即是unsigned int;
uc month;//uc即是unsigned char;
uc day;};
typedef datetype date;
union scoretype //重定義共用類型
{ fl sco1;
ch* sco2;};
typedef scoretype score;
enum numtype{one,two,three}; //重定義枚舉類型
typedef numtype num;
typedef num newnum; //重定義typedef類型
//(2)通常寫法(對(duì)無類型名的結(jié)構(gòu)、共用、枚舉定義語(yǔ)句直接重定義)
typedef struct{uc hou,min,sec;} time;
typedef union{fl sco1;ch* sco2;} sco;
typedef enum{red,green,blue} color;
//可見，無論何種寫法，都遵循typedef語(yǔ)句的格式：typedef 原類型 新類型;
//2.使用
date vs={2002,10,15};//定義結(jié)構(gòu)變量
printf("vs:%d.%d.%d ",vs.year,vs.month,vs.day);
score vu,*pu=&vu;printf("&vu=%x pu=%x ",&vu,pu);//定義共用指針
newnum ae[3]={one,two,three};//定義枚舉數(shù)組
printf("ae[0]=%d ae[1]=%d ae[2]=%d ",ae[0],ae[1],ae[2]);
static num vn;//定義帶存儲(chǔ)類別的對(duì)象
printf("vn=%d ",vn);
const sco cs={90};//定義const對(duì)象
printf("cs.sco1=%f ",cs.sco1);
time fun2(time);//作函數(shù)的參數(shù)和返回值類型
static time vt=fun2(vt);
printf("fun2:%d:%d:%d ",vt.hou,vt.min,vt.sec);
vn=(num)10;printf("vn=%d ",vn);//將新類型用作類型轉(zhuǎn)換
printf("$time=%d ",sizeof(time));//對(duì)新類型求長(zhǎng)度，$time=3
printf("$sco=%d ",sizeof(sco));//對(duì)新類型求長(zhǎng)度，$sco=4
printf("$color=%d ",sizeof(color));//對(duì)新類型求長(zhǎng)度，$color=4
//第3篇:typedef具體應(yīng)用
#include
int fun1(int a,int b){return 0;}
int fun2(int a,int b){return 0;}
int fun3(int a,int b){return 0;}
void main()
{ //一、使用typedef的優(yōu)點(diǎn)
//1可以為現(xiàn)有類型取一個(gè)更有意義的名字，增加程序的可讀性，如
typedef char* STRING;
STRING s1="string1",s2="string2";//STRING便可當(dāng)作字符串類型來使用
//2使變量定義更簡(jiǎn)短，減少書寫麻煩，如
typedef float A3[2][3][4];//為2*3*4的實(shí)型數(shù)組取簡(jiǎn)短的名字A3
A3 a,b,c;//相當(dāng)于定義float a[2][3][4],b[2][3][4],c[2][3][4]
typedef unsigned int(*PFUN)(int(*)[4]);//PFUN是一種函數(shù)指針，該類函數(shù)參數(shù)為一維數(shù)組型指針，返回值為無符號(hào)整型
PFUN pf1,pf2;//相當(dāng)于定義unsigned int(*pf1)(int(*)[4]);unsigned int(*pf2)(int(*)[4])
//3在定義復(fù)雜類型前，先用typedef建立一些中間類型，再用中間類型去構(gòu)造復(fù)雜類型，以降低其復(fù)雜性(主要用途)
//例：對(duì)于如下的復(fù)雜定義
int(*ap[3])(int,int);//ap是一個(gè)數(shù)組，其元素為函數(shù)型指針，該類函數(shù)的參數(shù)和返回值都是整型
//采用typedef以降低定義難度
//方法1
typedef int(*PF)(int,int);//定義PF為該種函數(shù)的指針
PF ap1[3];//ap1為一數(shù)組，每個(gè)元素都是PF類型
ap1[0]=fun1;ap1[1]=fun2;ap1[2]=fun3;
//方法2
typedef int FUN(int,int);//將該種函數(shù)定義為FUN類型
FUN* ap2[3];//ap2為一數(shù)組，每個(gè)元素都是指向FUN的指針
ap2[0]=fun1;ap2[1]=fun2;ap2[2]=fun3;
//4增加程序的可移植性(有利于程序在不同處理器、操作系統(tǒng)和編譯系統(tǒng)之間的移植)
/*例如，在TC下讀文件的程序段如下：
FILE* fp;
long buffer1;
fread(&buffer1,sizeof(long),1,fp);//每次讀出4個(gè)字節(jié)
若在VC下每次需要讀出8個(gè)字節(jié)，程序需如下修改：
double buffer2;
fread(&buffer2,sizeof(double),1,fp);
現(xiàn)用typedef方法，程序段如下：
typedef long UNIT;//UNIT在TC中代表long，在VC中代表double
UNIT buffer;
fread(&buffer,sizeof(UNIT),1,fp);//每次讀出UNIT個(gè)字節(jié)
當(dāng)移植到VC下時(shí)，只需改動(dòng)UNIT的定義即可：typedef double UNIT;*/
//二、typedef與define的區(qū)別
//用define也可實(shí)現(xiàn)簡(jiǎn)單的類型替換，如
#define INT long //用INT來代替long
//兩種方式的區(qū)別如下：
//1.二者處理時(shí)間不同，宏替換是在預(yù)編譯時(shí)進(jìn)行的，而類型定義是在正式編譯時(shí)處理的
//2二者本質(zhì)不同，宏替換只是將宏名簡(jiǎn)單替換為目標(biāo)字符串，而類型定義如同定義變量一樣
//是真的為程序增加了一種可用類型
//3.二者復(fù)雜性不同，用typedef可定義各種復(fù)雜的類型，并以各種方式使用新類型(詳見10_10_2.cpp)
//而define只能替換基本類型和自定義類型，無法替換派生類型，且使用起來很不安全，例如
#define pi int* //試圖用pi代替整型指針
pi pi1;//正確，展開后為int* pi1;
pi pi2,pi3;//錯(cuò)誤，原意是將pi2,pi3都定義成整型指針，但展開后為int* pi2,pi3; pi3并未定義成指針
#define NUM enum{one,two,three}//試圖用NUM代替該枚舉類型
NUM n1;//正確，定義了枚舉常量one,two,three和枚舉變量n1
//NUM n2;//錯(cuò)誤，展開后為enum{one,two,three}n2;從而造成枚舉常量one,two,three的重定義
#define DATE struct{int y,m,d;}
DATE *pd;//正確，定義了該結(jié)構(gòu)型指針
//pd=(DATE)1;//錯(cuò)誤，展開后為pi=(struct{int y,m,d;})1;目前尚不支持此種類型轉(zhuǎn)換寫法
#define TIME union{int h,m,s;}
//int L=sizeof(TIME);//錯(cuò)誤，展開后為int L=sizeof(union{int h,m,s;});sizeof操作數(shù)錯(cuò)誤
//可見，用define進(jìn)行類型替換時(shí)，會(huì)產(chǎn)生各種意想不到的錯(cuò)誤，故應(yīng)避免使用，而改用安全的typedef
}
|
|
QQ好友和群
QQ空間
騰訊微博
騰訊朋友
收藏
淘帖
頂
踩
