C基础--函数指针的使用

之前在看代码的时候，看了函数指针的使用，大体分为如下几类：

• 做一个function list，通过指针索引调用，使得处理功能类似的函数看起来更加清晰；
• 函数指针作为另一个函数的参数，用作回调；
• linux中经常使用来达到相同接口，实现不同，如：

 1 struct platform_driver {
 2     int (*probe)(struct platform_device *);
 3     int (*remove)(struct platform_device *);
 4     void (*shutdown)(struct platform_device *);
 5     int (*suspend)(struct platform_device *, pm_message_t state);
 6     int (*resume)(struct platform_device *);
 7     struct device_driver driver;
 8     const struct platform_device_id *id_table;
 9     bool prevent_deferred_probe;
10 };

实现可以是freescale的imx系列芯片的串口：

 1 static struct platform_driver serial_imx_driver = {
 2     .probe        = serial_imx_probe,
 3     .remove        = __devexit_p(serial_imx_remove),
 4 
 5     .suspend    = serial_imx_suspend,
 6     .resume        = serial_imx_resume,
 7     .id_table    = imx_uart_devtype,
 8     .driver        = {
 9         .name    = "imx-uart",
10         .owner    = THIS_MODULE,
11         .of_match_table = imx_uart_dt_ids,
12     },
13 };

下面摘自一个博客：

转自：http://blog.sina.com.cn/s/blog_4d48cc5d0100xnh9.html

用途：

函数指针通常用来实现回调，也可以用来对模块调用以函数表的形式进行优化。

 

使用方法：

 

1、定义函数指针类型

使用typedef更直观更方便 

1 // 定义一个原型为int Fun( int a );的函数指针
2 typedef int (*PTRFUN) ( int aPara );

typedef的功能是定义新的类型。这里定义了一种PTRFUN的类型，并定义这种类型为指向某种函数的指针，这种函数以一个int为参数并返回char类型。后面就可以像使用int,char一样使用PTRFUN了。

2、函数指针变量的定义

1 PTRFUN pFun; // pFun 为函数指针变量名
2 int (*pFun2) ( int a ); // pFun2也是函数指针变量名

3、函数指针作为函数的参数传递

 1 // 定义回调函数
 2 int CallBack( int a )
 3 {
 4     return ++a;
 5 }
 6 
 7 // 定义回调者函数
 8 void Caller( PTRFUN cb )    // void Caller( int (*cb) ( int ) ) // 也可这样申明
 9 {
10     int nPara = 1;  
11     int nRet = cb( nPara );
12 }
13 
14 
15 // 使用回调
16 void main()
17 {
18     Caller( CallBack ); // 直接使用回调函数
19     PTRFUN cb = CallBack; // int (*cb) ( int ); cb = CallBack;
20     int nRet1 = cb( 99 ); // nRet1 = 100;
21 }

 

4、函数指针的指针使用

 1 // 定义函数指针的指针
 2 typedef int (**PTRPTRFUN) ( int aPara );
 3 
 4 // 函数指针的指针作为参数
 5 // void PtrCaller( PTRFUN* cb ) // 指针申明
 6 // void PtrCaller( int (**cb) ( int ) ) // 原型申明
 7 void PtrCaller( PTRPTRFUN cb )
 8 {
 9     int nRet = (*cb)(999); // nRet = 1000;
10 }
11 
12 // 使用函数指针的指针
13 void main()
14 {
15     PTRFUN cb = CallBack;
16     PtrCaller( &cb );
17 }

5、函数指针数组的使用

1 // 函数指针数组的定义
2 PTRFUN fArray[10]
3 // int (*fArray[10]) ( int ); // 原型定义
4 for ( int i = 0; i < 10; i++ )
5 {
6     fArray[i] = CallBack;
7     int nRet = fArray[i](i); // nRet = i+1;
8 }

6、函数指针的大小

既然叫指针，所以跟普通的指针一样在32位系统下大小都为4

1 int nSz1 = sizeof(PTRFUN); // nSz1 = 4;
2 int nSz2 = sizeof(PTRPTRFUN); // nSz2 = 4;

使用实例：

这里给出一个使用函数指针的简单例子：

 1 //------------------------------------------------------
 2 #include 
 3 
 4 typedef int (*PTRFUN) ( int aPara , int bPara);
 5 
 6 int func1(int Pa, int Pb);
 7 int func2(int Pa, int Pb);
 8 int func3(int Pa, int Pb);
 9 int func4(int Pa, int Pb);
10 
11 void main()
12 {
13     int i = 0;
14     int j = 0;
15     PTRFUN pFuncArray[4] = {func1, func2, func3, func4};
16     PTRFUN pFunc; 
17 
18     for(i = 3; i >= 0; i --)
19     {
20         pFunc = pFuncArray[i];
21         printf("Output is: %d \n", (*pFunc)(i,i));
22     }
23 }
24 
25 int func1(int Pa, int Pb)
26 {
27     printf("func1 with input para %d, %d \n", Pa, Pb);
28     return Pa + Pb;
29 }
30 
31 int func2(int Pa, int Pb)
32 {
33     printf("func2 with input para %d, %d \n", Pa, Pb);
34     return Pa - Pb;
35 }
36 
37 int func3(int Pa, int Pb)
38 {
39     printf("func3 with input para %d, %d \n", Pa, Pb);
40     return Pa * Pb;
41 }
42 
43 int func4(int Pa, int Pb)
44 {
45     printf("func4 with input para %d, %d \n", Pa, Pb);
46     return (Pb == 0)? 0xffff : (Pa / Pb);
47 }

输出为：

 1 func4 with input para 3, 3
 2 Output is: 1
 3 
 4 func3 with input para 2, 2
 5 Output is: 4
 6 
 7 func2 with input para 1, 1
 8 Output is: 0
 9 
10 func1 with input para 0, 0
11 Output is: 0

 

转载于:https://www.cnblogs.com/aaronLinux/p/5769112.html