结构体中得函数指针，让我们更加方便~

转自：http://blog.csdn.net/unix21/article/details/9293877

结构体指针变量的定义，定义结构体变量的一般形式如下：

形式１：先定义结构体类型，再定义变量
struct结构体标识符
{
成员变量列表;…
};
struct 结构体标识符 *指针变量名;

变量初始化一：struct结构体标识符 变量名={初始化值1，初始化值2，…, 初始化值n };


形式２：在定义类型的同时定义变量
struct结构体标识符
{
成员变量列表;…
} *指针变量名;

变量初始化二：


形式３：直接定义变量，用无名结构体直接定义变量只能一次
struct
 {
成员变量列表;…
}*指针变量名;


其中“指针变量名”为结构体指针变量的名称。形式1是先定义结构体，然后再定义此类型的结构体指针变量；形式２和形式3是在定义结构体的同时定义此类型的结构体指针变量。


函数指针的定义

　　一般的函数指针可以这么定义:

　　int(*func)(int,int);

　　表示一个指向含有两个int参数并且返回值是int形式的任何一个函数指针. 假如存在这样的一个函数:

　　int add2(int x,int y)

　　{

　　return x+y;

　　}

　　那么在实际使用指针func时可以这样实现:

　　func=&add2; //指针赋值,或者func=add2; add2与&add2意义相同

　　printf("func(3,4)=%d\n",func(3,4));

　　事实上,为了代码的移植考虑,一般使用typedef定义函数指针类型.

　　typedef int(*FUN)(int,int);

　　FUN func=&add2;

　　func();



结构体中包含函数指针

其实在结构体中,也可以像一般变量一样,包含函数指针变量.下面是一种简单的实现.

[cpp]  view plain copy

1. #include <stdio.h>  
2. struct DEMO  
3. {  
4. int x,y;  
5. int (*func)(int,int); //函数指针  
6. };  
7.   
8. int add1(int x,int y)  
9. {  
10. return x*y;  
11. }  
12.   
13. int add2(int x,int y)  
14. {  
15. return x+y;  
16. }  
17.   
18. void main()  
19. {  
20. struct DEMO demo;  
21. demo.func=add2; //结构体函数指针赋值  
22. //demo.func=&add2; //结构体函数指针赋值  
23. printf("func(3,4)=%d\n",demo.func(3,4));  
24. demo.func=add1;  
25. printf("func(3,4)=%d\n",demo.func(3,4));  
26. }  
27.   
28. /* 
29. 输出： 
30. func(3,4)=7 
31. func(3,4)=12 
32. */  

结构体中指向函数的指针                                          

C语言中的struct是最接近类的概念，但是在C语言的struct中只有成员，不能有函数，但是可以有指向函数的指针，这也就方便了我们使用函数了。举个例子，如下：

[cpp]  view plain copy

1. #include <stdio.h>  
2. #include <stdlib.h>  
3. #include <string.h>  
4.   
5. typedef struct student  
6. {  
7.     int id;  
8.     char name[50];   
9.     void (*initial)();  
10.     void (*process)(int id, char *name);  
11.     void (*destroy)();  
12. }stu;  
13.   
14. void initial()  
15. {  
16.     printf("initialization...\n");  
17. }  
18.   
19. void process(int id, char *name)  
20. {  
21.     printf("process...\n%d\t%s\n",id, name);  
22. }  
23.   
24. void destroy()  
25. {  
26.     printf("destroy...\n");  
27. }  
28.   
29. int main()  
30. {  
31.     stu *stu1;  
32.     //在VC和TC下都需要malloc也可以正常运行，但是linux gcc下就会出错，为段错误，必须malloc  
33.     stu1=(stu *)malloc(sizeof(stu));  
34.     //使用的时候必须要先初始化  
35.     stu1->id=1000;  
36.     strcpy(stu1->name,"C++");  
37.     stu1->initial=initial;  
38.     stu1->process=process;  
39.     stu1->destroy=destroy;  
40.     printf("%d\t%s\n",stu1->id,stu1->name);  
41.     stu1->initial();  
42.     stu1->process(stu1->id, stu1->name);  
43.     stu1->destroy();  
44.     free(stu1);  
45.     return 0;  
46. }  

输出：

/*
1000    C++
initialization...
process...
1000    C++
destroy...
*/

c语言中，如何在结构体中实现函数的功能？把结构体做成和类相似，让他的内部有属性，也有方法
这样的结构体一般称为协议类，提供参考： 
struct { 
 int funcid; 
 char *funcname; 
 int (*funcint)(); /* 函数指针 int 类型*/ 
 void (*funcvoid)(); /* 函数指针 void类型*/ 
}; 
每次都需要初始化，比较麻烦

 

[cpp]  view plain copy

1. #include <stdio.h>  
2.   
3. typedef struct  
4. {  
5. int a;  
6. void (*pshow)(int);  
7. }TMP;  
8.   
9. void func(TMP *tmp)  
10. {  
11.     if(tmp->a >10)//如果a>10,则执行回调函数。  
12.     {  
13.         (tmp->pshow)(tmp->a);  
14.     }  
15. }  
16.   
17. void show(int a)  
18. {  
19.     printf("a的值是%d\n",a);  
20. }  
21.   
22. void main()  
23. {  
24.     TMP test;  
25.     test.a = 11;  
26.     test.pshow = show;  
27.     func(&test);  
28. }  
29.   
30. /* 
31. 一般回调函数的用法为： 
32. 甲方进行结构体的定义（成员中包括回调函数的指针） 
33.  
34. 乙方定义结构体变量，并向甲方注册， 
35. 甲方收集N个乙方的注册形成结构体链表，在某个特定时刻遍历链表，进行回调。 
36. 当 函数指针 做为函数的参数，传递给一个被调用函数， 
37. 被调用函数就可以通过这个指针调用外部的函数，这就形成了回调<p>一般的程序中回调函数作用不是非常明显，可以不使用这种形式</p><p>最主要的用途就是当函数不处在同一个文件当中，比如动态库，要调用其他程序中的函数就只有采用回调的形式 
38. 通过函数指针参数将外部函数地址传入来实现调用</p><p>函数的代码作了修改，也不必改动库的代码，就可以正常实现调用便于程序的维护和升级</p>*/