1.簡單的函式指標的應用

形式1：返回型別(*函式名)(引數表) 

1. char (*pFun)(int);   
2. char glFun(int a){ return;}   
3. void main()   
4. {   
5.     pFun = glFun;   
6.     (*pFun)(2);   
7. }  

char (*pFun)(int); 
char glFun(int a){ return;} 
void main() 
{ 
    pFun = glFun; 
    (*pFun)(2); 
}

         第一行定義了一個指標變數pFun。首先我們根據前面提到的“形式1”認識到它是一個指向某種函式的指標，這種函式引數是一個int型，返回值是char型別。只有第一句我們還無法使用這個指標，因為我們還未對它進行賦值。
         第二行定義了一個函式glFun()。該函式正好是一個以int為引數返回char的函式。我們要從指標的層次上理解函式——函式的函式名實際上就是一個指標，函式名指向該函式的程式碼在記憶體中的首地址
         然後就是main()函數了，它的第一句您應該看得懂了——它將函式glFun的地址賦值給變數pFun。main()函式的第二句中“*pFun”顯然是取pFun所指向地址的內容，當然也就是取出了函式glFun()的內容，然後給定引數為2。

2.使用typedef更直觀更方便

形式1：typedef  返回型別(*新型別)(引數表)

1. typedefchar (*PTRFUN)(int);   
2. PTRFUN pFun;   
3. char glFun(int a){ return;}   
4. void main()   
5. {   
6.     pFun = glFun;   
7.     (*pFun)(2);   
8. }   

typedef char (*PTRFUN)(int); 
PTRFUN pFun; 
char glFun(int a){ return;} 
void main() 
{ 
    pFun = glFun; 
    (*pFun)(2); 
} 
 

            typedef的功能是定義新的型別。第一句就是定義了一種PTRFUN的型別，並定義這種型別為指向某種函式的指標，這種函式以一個int為引數並返回char型別。後面就可以像使用int,char一樣使用PTRFUN了。
           第二行的程式碼便使用這個新型別定義了變數pFun，此時就可以像使用形式1一樣使用這個變量了。

3.例子說明

1. #include <stdio.h>
2. #include <assert.h>
3. typedefint (*FP_CALC)(int,int);//定義一個函式指標型別
4. int add(int a, int b)  
5. {  
6.     return a + b;  
7. }  
8. int sub(int a, int b)  
9. {  
10.     return a - b;  
11. }  
12. int mul(int a, int b)  
13. {  
14.     return a * b;  
15. }  
16. int div(int a, int b)  
17. {  
18.     return b ? a/b : -1;  
19. }  
20. //定義一個函式，引數為op，返回一個指標,該指標型別為擁有兩個int引數、
21. //返回型別為int的函式指標。它的作用是根據操作符返回相應函式的地址
22. FP_CALC calc_func(char op)  
23. {  
24.     switch( op )  
25.     {  
26.     case‘+’:  
27.         return add;  
28.     case‘-‘:  
29.         return sub;  
30.     case‘*’:  
31.         return mul;  
32.     case‘/’:  
33.         return div;  
34.     default:  
35.         return NULL;  
36.     }  
37.     return NULL;  
38. }  
39. //s_calc_func為函式，它的引數是 op，   
40. //返回值為一個擁有兩個int引數、返回型別為int的函式指標  
41. int (*s_calc_func(char op)) (int , int)  
42. {  
43.     return calc_func(op);  
44. }  
45. //終端使用者直接呼叫的函式，該函式接收兩個int整數，
46. //和一個算術運算子，返回兩數的運算結果
47. int calc(int a, int b, char op)  
48. {  
49.     FP_CALC fp = calc_func(op);  
50.     int (*s_fp)(int,int) = s_calc_func(op);//用於測試
51.     assert(fp == s_fp);// 可以斷言這兩個是相等的
52.     if(fp)  
53.         return fp(a,b);  
54.     else
55.         return -1;  
56. }  
57. void main()  
58. {  
59.     int a = 100, b = 20;  
60.     printf(”calc(%d, %d, %c) = %d\n”, a, b, ‘+’, calc(a, b, ‘+’));  
61.     printf(”calc(%d, %d, %c) = %d\n”, a, b, ‘-‘, calc(a, b, ‘-‘));     
62.     printf(”calc(%d, %d, %c) = %d\n”, a, b, ‘*’, calc(a, b, ‘*’));     
63.     printf(”calc(%d, %d, %c) = %d\n”, a, b, ‘/’, calc(a, b, ‘/’));   
64. }  

#include <stdio.h>

include <assert.h>

typedef int (*FP_CALC)(int,int);//定義一個函式指標型別

int add(int a, int b)
{
return a + b;
}

int sub(int a, int b)
{
return a - b;
}

int mul(int a, int b)
{
return a * b;
}

int div(int a, int b)
{
return b ? a/b : -1;
}

//定義一個函式，引數為op，返回一個指標,該指標型別為擁有兩個int引數、
//返回型別為int的函式指標。它的作用是根據操作符返回相應函式的地址
FP_CALC calc_func(char op)
{
switch( op )
{
case '+':
return add;
case '-':
return sub;
case '*':
return mul;
case '/':
return div;
default:
return NULL;
}
return NULL;
}

//s_calc_func為函式，它的引數是 op，
//返回值為一個擁有兩個int引數、返回型別為int的函式指標
int (*s_calc_func(char op)) (int , int)
{
return calc_func(op);
}

//終端使用者直接呼叫的函式，該函式接收兩個int整數，
//和一個算術運算子，返回兩數的運算結果
int calc(int a, int b, char op)
{
FP_CALC fp = calc_func(op);
int (*s_fp)(int,int) = s_calc_func(op);//用於測試

assert(fp == s_fp);// 可以斷言這兩個是相等的

if(fp)
    return fp(a,b);
else
    return -1;

}

void main()
{
int a = 100, b = 20;

printf("calc(%d, %d, %c) = %d\n", a, b, '+', calc(a, b, '+'));
printf("calc(%d, %d, %c) = %d\n", a, b, '-', calc(a, b, '-'));   
printf("calc(%d, %d, %c) = %d\n", a, b, '*', calc(a, b, '*'));   
printf("calc(%d, %d, %c) = %d\n", a, b, '/', calc(a, b, '/')); 

}

參考：

                </div>