define與typedef區別與聯絡

bbs598598發表於2012-11-01
#define N 5    表示N的值為5
typedef struct s{int k}node; 表示node和struct s有一樣的功能  ,比如你要定義剛才這個結構體的話，
    寫struct s head,和node head表示的是一個意思，都是新建立了一個struct s之類的結構體


總的來說我認為，define的作用是把一個變數賦值為常量，比如#define N 5
                            而typedef的作用就是把一個型別名可以用另外一個更簡明的字母代替，比如
                struct s head,和node head


#define(巨集定義)只是簡單的字串代換(原地擴充套件)，它本身並不在編譯過程中進行，而是在這之前(預處理過程)就已經完成了。
typedef是為了增加可讀性而為識別符號另起的新名稱(僅僅只是個別名)，它的新名字具有一定的封裝性，以致於新命名的識別符號具有更易定義變數的功能，它是語言編譯過程的一部分，但它並不實際分配記憶體空間。
一般都遵循#define定義“可讀”的常量以及一些巨集語句的任務，而typedef則常用來定義關鍵字、冗長的型別的別名。
typedef是語句（ 以'；'結尾），而#define不是語句（ 不以'；'結尾）
typedef      (int*)        pINT;
以及下面這行:
#define      pInt      int*
效果相同？實則不同！
實踐中見差別：
pINT a,b;的效果同int * a; int * b; 表示定義了兩個整型指標變數a和b;
pInt a,b;的效果同int * a; int b; 表示定義一個整型指標變數a和一個整形變數b;
#define與const區別（定義常量）：
1. const常量有資料型別，而#define（巨集）常量沒有資料型別。編譯器可以對前者進行型別安全檢查。而對後者只進行字元替換，沒有型別安全檢查，並且在字元替換可能會產生意料不到的錯誤（邊際效應）。
2. const常量在堆疊分配了空間，而#define（巨集）常量只是把具體數值直接傳遞到目標變數罷了。或者說，const的常量是一個Run-Time的 概念，他在程式中確確實實的存在並可以被呼叫、傳遞。而#define常量則是一個Compile-Time概念，它的生命週期止於編譯期：在實際程式中 他只是一個常數、一個命令中的引數，沒有實際的存在。
3. const常量存在於程式的資料段，#define常量存在於程式的程式碼段。
4. 有些整合化的除錯工具可以對const常量進行除錯，但是不能對巨集常量進行除錯。
#define的用法：
1、簡單的巨集定義
#define MAXTIME 1000一個簡單的MAXTIME就定義好了，它代表1000，如果在程式裡面寫：
if(i<MAXTIME){}編譯器在處理這個程式碼之前會對MAXTIME進行處理替換為1000。
這樣的定義看起來類似於普通的常量定義const，但也有著不同，因為define的定義只是簡單的替換，而不是作為一個量來使用，這個問題在下面反映的尤為突出。

2、帶引數的巨集
define可以像函式那樣接受一些引數，如下：
#define max(x,y) (x)>(y)?(x):(y);它將返回兩個數中較大的那個，這個“函式”沒有型別檢查，就好像一個函式模板似的，當然，不難看出它絕對沒有模板那麼安全。
因為這樣做的話存在隱患，例子如下：
#define Add(a,b) a+b;一般的單獨使用是沒有問題的，但是如果遇到如：c * Add(a,b) * d的時候就會出現問題，代數式的本意是a+b然後和c，d相乘，但是因為使用了define（它只是一個簡單的替換），所以式子實際上變成了c*a + b*d 。
再看看這個例子：
#define int_ptr int *;
int_ptr a,b;本意是a和b都是int型指標，但是實際上變成int* a,b;a是int型指標，而b是int型變數。這時應該使用typedef定義：typedef int* int_ptr;
int_ptr a,b;這樣a和b就都是int型指標了。

3、define的多行定義
define可以替代多行的程式碼，例如MFC中的巨集定義（非常的經典，雖然讓人看了噁心）
#define MACRO(arg1, arg2) do { \
/**//* declarations */ \
stmt1; \
stmt2; \
/**//*  */ \
} while(0) /**//* (no trailing ; ) */關鍵是要在每一個換行的時候加上一個"\"。

4、在大規模的開發過程中，特別是跨平臺和系統的軟體裡，define最重要的功能是條件編譯。
#ifdef WINDOWS


#endif
#ifdef LINUX


#endif可以在編譯的時候通過#define設定編譯環境

5、如何定義巨集、取消巨集
//定義巨集
#define [MacroName] [MacroValue]
//取消巨集
#undef [MacroName]
//普通巨集
#define PI (3.1415926)
//帶引數的巨集
#define max(a,b) ((a)>(b)? (a),(b))關鍵是十分容易產生錯誤，包括機器和人理解上的差異等等。

6、條件編譯
#ifdef XXX…(#else) …#endif
例如：
#ifdef DV22_AUX_INPUT
#define AUX_MODE 3
#else
#define AUY_MODE 3
＃endif

#define和typedef的區別：

1、 #define是預處理指令，在編譯預處理時進行簡單的替換，不作正確性檢查，不管含義是否正確照樣帶入，只有在編譯已被展開的源程式時才會發現可能的錯誤並報錯。例如：
#define PI 3.1415926
程式中的：area=PI*r*r 會替換為3.1415926*r*r
如果你把#define語句中的數字9 寫成字母g 預處理也照樣帶入。

2、typedef是在編譯時處理的。它在自己的作用域內給一個已經存在的型別一個別名，但是You cannot use the typedef specifier inside a function definition。

3、   typedef int * int_ptr;與
#define int_ptr int *作用都是用int_ptr代表 int * ，但是二者不同，正如前面所說，#define在預處理時只是進行簡單的替換，而typedef不是簡單替換 ，而是採用如同定義變數的方法那樣來宣告一種型別。重複前面的例子：
#define int_ptr int *
int_ptr a,b; //相當於int * a, b; 只是簡單的巨集替換，a是整型指標，而b之是整型變數
typedef int * int_ptr;
int_ptr a,b; //a, b 都為指向int的指標,typedef為int* 引入了一個新的助記符

4、也許您已經注意到#define不是語句，不要在行末加分號，否則會連分號一塊置換；但是typedef結束必須加分號，因為它是語句。
typedef的四個用途和兩個陷阱
用途一： 
定義一種型別的別名，而不只是簡單的巨集替換。可以用作同時宣告指標型的多個物件。比如： 
char*     pa,     pb;       //     這多數不符合我們的意圖，它只宣告瞭一個指向字元變數的指標，   
//     和一個字元變數； 
以下則可行： 
typedef     char*     PCHAR;       //     一般用大寫 
PCHAR     pa,     pb;                   //     可行，同時宣告瞭兩個指向字元變數的指標 
雖然： 
char     *pa,     *pb; 
也可行，但相對來說沒有用typedef的形式直觀，尤其在需要大量指標的地方，typedef的方式更省事。 
用途二： 
用在舊的C程式碼中（具體多舊沒有查），幫助struct。以前的程式碼中，宣告struct新物件時，必須要帶上struct，即形式為：     struct     結構名     物件名，如： 
struct     tagPOINT1 
{ 
          int     x; 
          int     y; 
}; 
struct     tagPOINT1     p1;   
而在C++中，則可以直接寫：結構名     物件名，即： 
tagPOINT1     p1; 
估計某人覺得經常多寫一個struct太麻煩了，於是就發明了： 
typedef     struct     tagPOINT 
{ 
          int     x; 
          int     y; 
}POINT; 
POINT     p1;     //     這樣就比原來的方式少寫了一個struct，比較省事，尤其在大量使用的時候 
或許，在C++中，typedef的這種用途二不是很大，但是理解了它，對掌握以前的舊程式碼還是有幫助的，畢竟我們在專案中有可能會遇到較早些年代遺留下來的程式碼。 
用途三： 
用typedef來定義與平臺無關的型別。 
比如定義一個叫     REAL     的浮點型別，在目標平臺一上，讓它表示最高精度的型別為： 
typedef     long     double     REAL;   
在不支援     long     double     的平臺二上，改為： 
typedef     double     REAL;   
在連     double     都不支援的平臺三上，改為： 
typedef     float     REAL;   
也就是說，當跨平臺時，只要改下     typedef     本身就行，不用對其他原始碼做任何修改。 
標準庫就廣泛使用了這個技巧，比如size_t。 
另外，因為typedef是定義了一種型別的新別名，不是簡單的字串替換，所以它比巨集來得穩健（雖然用巨集有時也可以完成以上的用途）。 
用途四： 
為複雜的宣告定義一個新的簡單的別名。方法是：在原來的宣告裡逐步用別名替換一部分複雜宣告，如此迴圈，把帶變數名的部分留到最後替換，得到的就是原宣告的最簡化版。舉例： 
1.     原宣告：int     *(*a[5])(int,     char*); 
變數名為a，直接用一個新別名pFun替換a就可以了： 
typedef     int     *(*pFun)(int,     char*);   
原宣告的最簡化版： 
pFun     a[5];   
2.     原宣告：void     (*b[10])     (void     (*)()); 
變數名為b，先替換右邊部分括號裡的，pFunParam為別名一： 
typedef     void     (*pFunParam)(); 
再替換左邊的變數b，pFunx為別名二： 
typedef     void     (*pFunx)(pFunParam); 
原宣告的最簡化版： 
pFunx     b[10]; 
3.     原宣告：doube(*)()     (*e)[9];   
變數名為e，先替換左邊部分，pFuny為別名一： 
typedef     double(*pFuny)(); 
再替換右邊的變數e，pFunParamy為別名二 
typedef     pFuny     (*pFunParamy)[9]; 
原宣告的最簡化版： 
pFunParamy     e;   
理解複雜宣告可用的“右左法則”：從變數名看起，先往右，再往左，碰到一個圓括號就調轉閱讀的方向；括號內分析完就跳出括號，還是按先右後左的順序，如此迴圈，直到整個宣告分析完。舉例： 
int     (*func)(int     *p); 
首先找到變數名func，外面有一對圓括號，而且左邊是一個*號，這說明func是一個指標；然後跳出這個圓括號，先看右邊，又遇到圓括號，這說明 (*func)是一個函式，所以func是一個指向這類函式的指標，即函式指標，這類函式具有int*型別的形參，返回值型別是int。 
int     (*func[5])(int     *); 
func右邊是一個[]運算子，說明func是具有5個元素的陣列；func的左邊有一個*，說明func的元素是指標（注意這裡的*不是修飾func， 而是修飾func[5]的，原因是[]運算子優先順序比*高，func先跟[]結合）。跳出這個括號，看右邊，又遇到圓括號，說明func陣列的元素是函式 型別的指標，它指向的函式具有int*型別的形參，返回值型別為int。 
也可以記住2個模式： 
type     (*)(....)函式指標   
type     (*)[]陣列指標   
陷阱一： 
記住，typedef是定義了一種型別的新別名，不同於巨集，它不是簡單的字串替換。比如： 
先定義： 
typedef     char*     PSTR; 
然後： 
int     mystrcmp(const     PSTR,     const     PSTR); 
const     PSTR實際上相當於const     char*嗎？不是的，它實際上相當於char*     const。 
原因在於const給予了整個指標本身以常量性，也就是形成了常量指標char*     const。 
簡單來說，記住當const和typedef一起出現時，typedef不會是簡單的字串替換就行。 
陷阱二： 
typedef在語法上是一個儲存類的關鍵字（如auto、extern、mutable、static、register等一樣），雖然它並不真正影響物件的儲存特性，如： 
typedef     static     int     INT2;     //不可行 
編譯將失敗，會提示“指定了一個以上的儲存類”。






相關文章