C 中typedef 函數指標的使用

標籤：

類型定義的文法可以歸結為一句話：只要在變數定義前面加上typedef，就成了類型定義。這兒的原本應該是變數的東西，就成為了類型。

int integer;     //整型變數
int *pointer;   //整型指標變數
int array [5]; //整型陣列變數
int *p_array [5]; //整型指標的數組的變數
int (*array_pointer) [5];//整型數組的指標的變數
int function (int param);//函數定義，也可將函數名看作函數的變數
int *function (int param);//仍然是函數，但傳回值是整型指標
int (*function) (int param);//現在就是指向函數的指標了

若要定義相應類型，即為類型來起名字，就是下面的形式：
typedef int integer_t;                      //整數型別
typedef int *pointer_t;     //整型指標類型
typedef int array_t [5]; //整型數群組類型
typedef int *p_array_t [5];    //整型指標的數組的類型
typedef int (*array_pointer_t) [5]; //整型數組的指標的類型
typedef int function_t (int param);     //函數類型
typedef int *function_t (int param);    //函數類型
typedef int (*function_t) (int param); //指向函數的指標的類型
注意：上面的函數類型在C中可能會出錯，因為C中並沒有函數類型，它的函數變數會自動退化成函數指標；在C++中好像是可以的。在這裡主要說明的是形式上的相似性.

typedef的一般形式為：
typedef   類型     定義名;
在編程中使用typedef目的一般有兩個，一個是給變數一個易記且意義明確的新名字，另一個是簡化一些比較複雜的型別宣告。
其實，在C語言中聲明變數的時候，有個儲存類型指示符（storage-class-specifier），它包括我們熟悉的extern、static、auto、register。在不指定儲存類型指示符的時候，編譯器會根據約定自動取預設值。另外，儲存類型指示符的位置也是任意的（但要求在變數名和指標*之前），也就是說以下幾行代碼是等價的：
static const int i;
const static int i;
int const static i;
const int static i;
根據C語言規範，在進行句法分析的時候，typedef和儲存類型指示符是等價的！所以，我們把上述使用static的地方替換為typedef：
typedef const int i;
const typedef int i;
int const typedef i;
const int typedef i;
上述代碼的語義是：將i定義為一個類型名，其等價的類型為const int。以後如果我們有i   a代碼，就等價於const int a。對於有指標的地方也是一樣的，比如：
int const typedef *t;那麼代碼t   p。就相當於int const *p。
另外，typedef不能和static等儲存類型指示符同時使用，因為每個變數只能有一種儲存類型，所以代碼：typedef static int i;是非法的。

typedef有兩種用法：
一、一般形式，定義已有類型的別名
　　typedef   類型    定義名;
二、建立一個新的類型
     typedef   傳回值類型   新類型名(參數列表);

1）typedef int NUM[10];//聲明整型數群組類型

    NUM n;//定義n為整型陣列變數，其中n[0]--n[9]可用

2）typedef char* STRING;//聲明STRING為字元指標類型

    STRING p,s[10];//p為字元指標變數，s為指標數組

3）typedef int (*POINTER)();//聲明POINTER為指向函數的指標類型，該函數返回整型值,沒有參數

    POINTER P1,P2;//p1，p2為POINTER類型的指標變數

 

說明：

      1）用typedef可以聲明各種類型名，但不能用來定義變數，用typedef可以聲明數群組類型、字串類型、使用比較方便。

例如：定義數組，原來是用：int a[10],b[10],c[10],d[10];由雩都是一維數組，大小也相同，可以先將此數群組類型聲明為一個名字：

typedef int ARR[10];

然後用ARR去定義陣列變數：

ARR a,b,c,d;//ARR為數群組類型，它包含10個元素。因此a,b,c,d都被定義為一維數組，含10個元素。可以看到，用typedef可以將 數群組類型 和 陣列變數 分離開來，利用數群組類型可以定義多個陣列變數。同樣可以定義字串類型、指標類型等。

      2）用typedef只是對已經存在的類型增加一個類型名，而沒有創造新的類型。

      3）typedef與#define有相似之處，但事實上二者是不同的，#define是在 先行編譯 時處理，它只能做簡單的字串替換，而typedef是在 編譯時間 處理的。它並不是做簡單的字串替換，而是採用如同 定義變數 的方法那樣來 聲明 一個類型。

例如：typedef int COUNT;和#define COUNT int的作用都是用COUNT代表int，單事實上它們二者是不同的。

兩個陷阱：

陷阱一： 
記住，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; //不可行
編譯將失敗，會提示“指定了一個以上的儲存類”。

1.typedef  函數指標的使用方法

(1)typedef 首先是用來定義新的類型,i.e typedef struct {.....}mystruct; 在以後引用時，就可以用 mystruct 來定義自己的結構體，mystruct structname1，mystruct structname2.

(2)typedef 常用的地方，就在定義函數指標，行為和宏定義類似，用實際類型替換同義字，但是有區別： typedef 在編譯時間被解釋，因此讓編譯器來應付超越前置處理器能力的文本替換。

案例一： 
通常講，typedef要比#define要好，特別是在有指標的場合。請看例子： 
typedef char *pStr1; 
#define pStr2 char *; 
pStr1 s1, s2; 
pStr2 s3, s4; 
在上述的變數定義中，s1、s2、s3都被定義為char *，而s4則定義成了char，不是我們所預期的指標變數，根本原因就在於#define只是簡單的字串替換而typedef則是為一個類型起新名字。 
案例二： 
下面的代碼中編譯器會報一個錯誤，你知道是哪個語句錯了嗎？ 
typedef char * pStr; 
char string[4] = "abc"; 
const char *p1 = string; 
const pStr p2 = string; 
p1++; 
p2++; 
是p2++出錯了。這個問題再一次提醒我們：typedef和#define不同，它不是簡單的文本替換。上述代碼中const pStr p2並不等於const char * p2。const pStr p2和const long x本質上沒有區別，都是對變數進行唯讀限制，只不過此處變數p2的資料類型是我們自己定義的而不是系統固有類型而已。因此，const pStr p2的含義是：限定資料類型為char *的變數p2為唯讀，因此p2++錯誤。

 

用法一：

 typedef  傳回型別(*新類型)(參數表)

 typedef int ( * MYFUNCTION )( int,int ); 這種用法一般是在定義函數指標 MYFUNCTION 是一個函數指標類型 有兩個整型的參數，返回一個整型。

在對於這樣的形式，去掉typedef和別名 就剩下了的是原變數的類型 如：int (*)(int ,int); 在函數指標中，抽象得看待函數,函數名其實就是一個地址,函數名指向該函數的代碼在記憶體的首地址。

用法二： 複雜函式宣告類型

 下面是三個變數的聲明  用typedef 如何來做？？？

>1 int *(*a[5])(void *,void *);

>2 void (*b[5])(void (*)());

>3 float (*)()(*pa)[10];

分析如下：

>1 int *(*a[5])(void *,void *);

//pFUN是自己建立的類型別名 typedef int *(* pFUN)(void  *,void *); //等價於int *(*a[5])(void *,void *); 

pFUN a[5];  a是一個數組，包含五個元素，這些元素都是函數指標,該函數指標所指的函數的傳回值是int的指標 輸入參數有兩個都是void *.

>2 void (*b[5])( void (*)() );

// first 為藍色的 聲明一個新的類型 typedef void (*pFUNParam)( );

//整體聲明一個新類型  typedef void (*pFUN)(FUNParam); 

//使用定義的新型別宣告對象 等價於void (*b[5])( void (*)() ); 

pFUN b[5]; b 是一個含有5個元素的數組,每個元素都是一個函數指標，該函數指標所指的函數的傳回值是void.輸入參數是另一個函數指標,這個函數指標沒有參數,傳回值為空白。在這裡套用了連續的函數指標。本身就是一個函數指標，而且參數也是一個函數指標。

>3 float (*)()(*pa)[10];

//first 為上面的藍色運算式聲明一個新類型 typedef float (*pFUN)(); 

//整體聲明一個新類型typedef pFUN (* pFunParam)[10];

//使用定義的新類型來聲明對象 等價與float (*)()(*pa)[10];

pa 是一個指標，指標指向一個含有10個元素的數組,數組的元素是函數指標,函數指標所指的函數沒有輸入參數,傳回值為float.

**********************************************

使用typedef簡化複雜的變數聲明
1）、定義一個有10個指標的數組，該指標指向一個函數，該函數有一個整形參數，並返回一個整型？
第一種方法：int (*a[10])(int);
第二種方法：typedef int (*pfunc)(int);
             pfunc a[10];
2）、定義一個有10個指標的數組，該指標指向一個函數，該函數有一個函數指標（不帶參數，傳回值為空白）參數，並返回空。
第一種方法：void (*a[10])(void (*)(void));
第二種方法：typedef void (*pfuncParam)(void);
               typedef void (*pfunc)(pfuncParam);
pfunc a[10];
3）、一個指向有10個函數指標（不帶參數，傳回值為double）數組的指標
第一種方法：double (*)(void) (*p)[10];
第二種方法：typedef double (*pfunc)(void);
             typedef pfunc (*pfuncParam)[10];
             pfuncParam p;

從變數名看起，先往右，再往左，碰到一個圓括弧就調轉閱讀的方向；括弧內分析完就跳出括弧，還是按先右後左的順序，如此迴圈，直到整個聲明分析完。舉例：
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 (*)[]數組指標 

**********************************************

finally 

typedef 使用最多的地方是建立易於記憶的類型名，用它來歸檔程式員的意圖。類型出現在所聲明的變數名字中，位於 ‘‘typedef‘‘ 關鍵字右邊。例如：
typedef int size;此聲明定義了一個 int 的同義字，名字為 size。注意 typedef 並不建立新的類型。它僅僅為現有類型添加一個同義字。你可以在任何需要 int 的上下文中使用 size：
void measure(size * psz); size array[4];size len = file.getlength();std::vector <size> vs; typedef 還可以掩飾符合類型，如指標和數組。例如，你不用象下面這樣重複定義有 81 個字元元素的數組：
char line[81];char text[81];定義一個 typedef，每當要用到相同類型和大小的數組時，可以這樣：
typedef char Line[81]; Line text, secondline;getline(text);同樣，可以象下面這樣隱藏指標文法：
typedef char * pstr;int mystrcmp(pstr, pstr);這裡將帶我們到達第一個 typedef 陷阱。標準函數 strcmp()有兩個‘const char *‘類型的參數。因此，它可能會誤導人們象下面這樣聲明 mystrcmp()：
int mystrcmp(const pstr, const pstr); 這是錯誤的，按照順序，‘const pstr‘被解釋為‘char * const‘（一個指向 char 的常量指標），而不是‘const char *‘（指向常量 char 的指標）。這個問題很容易解決：
typedef const char * cpstr; int mystrcmp(cpstr, cpstr); // 現在是正確的記住：不管什麼時候，只要為指標聲明 typedef，那麼都要在最終的 typedef 名稱中加一個 const，以使得該指標本身是常量，而不是對象。 
代碼簡化
上面討論的 typedef 行為有點像 #define 宏，用其實際類型替代同義字。不同點是 typedef 在編譯時間被解釋，因此讓編譯器來應付超越前置處理器能力的文本替換。例如：
typedef int (*PF) (const char *, const char *);這個聲明引入了 PF 類型作為函數指標的同義字，該函數有兩個 const char * 類型的參數以及一個 int 類型的傳回值。如果要使用下列形式的函式宣告，那麼上述這個 typedef 是不可或缺的：
PF Register(PF pf);Register() 的參數是一個 PF 類型的回呼函數，返回某個函數的地址，其署名與先前註冊的名字相同。做一次深呼吸。下面我展示一下如果不用 typedef，我們是如何?這個聲明的：
int (*Register (int (*pf)(const char *, const char *))) (const char *, const char *); 很少有程式員理解它是什麼意思，更不用說這種費解的代碼所帶來的出錯風險了。顯然，這裡使用 typedef 不是一種特權，而是一種必需。持懷疑態度的人可能會問：“OK，有人還會寫這樣的代碼嗎？”，快速探索一下揭示 signal()函數的標頭檔 <csinal>，一個有同樣介面的函數。 
typedef 和儲存類關鍵字（storage class specifier）
這種說法是不是有點令人驚訝，typedef 就像 auto，extern，mutable，static，和 register 一樣，是一個儲存類關鍵字。這並是說 typedef 會真正影響對象的儲存特性；它只是說在語句構成上，typedef 聲明看起來象 static，extern 等類型的變數聲明。下面將帶到第二個陷阱：
typedef register int FAST_COUNTER; // 錯誤編譯通不過。問題出在你不能在聲明中有多個儲存類關鍵字。因為符號 typedef 已經佔據了儲存類關鍵字的位置，在 typedef 聲明中不能用 register（或任何其它儲存類關鍵字）。 
促進跨平台開發
typedef 有另外一個重要的用途，那就是定義機器無關的類型，例如，你可以定義一個叫 REAL 的浮點類型，在目標機器上它可以i獲得最高的精度：
typedef long double REAL; 在不支援 long double 的機器上，該 typedef 看起來會是下面這樣：
typedef double REAL; 並且，在連 double 都不支援的機器上，該 typedef 看起來會是這樣： 、
typedef float REAL; 你不用對原始碼做任何修改，便可以在每一種平台上編譯這個使用 REAL 類型的應用程式。唯一要改的是 typedef 本身。在大多數情況下，甚至這個微小的變動完全都可以通過奇妙的條件編譯來自動實現。不是嗎? 標準庫廣泛地使用 typedef 來建立這樣的平台無關類型：size_t，ptrdiff 和 fpos_t 就是其中的例子。此外，象 std::string 和 std::ofstream 這樣的 typedef 還隱藏了長長的，難以理解的模板特化文法，例如：basic_string<char, char_traits<char>，allocator<char>> 和 basic_ofstream<char, char_traits<char>>。

 

C 中typedef 函數指標的使用