免费注册 查看新帖 |

Chinaunix

  平台 论坛 博客 文库
最近访问板块 发新帖
查看: 8252 | 回复: 7

[函数] 谁能举一个简单的回调函数的例子啊?? [复制链接]

论坛徽章:
0
发表于 2004-04-16 18:17 |显示全部楼层
谢谢大家

论坛徽章:
0
发表于 2004-04-16 19:10 |显示全部楼层

谁能举一个简单的回调函数的例子啊??


  1. #include <stdio.h>;

  2. void callback( )
  3. {
  4.         printf( "Hello World!\n" );
  5. }

  6. void func( void call() )
  7. {
  8.         call( );       
  9. }

  10. void main( )
  11. {
  12.         func( callback );
  13. }

复制代码

论坛徽章:
0
发表于 2004-04-16 21:30 |显示全部楼层

谁能举一个简单的回调函数的例子啊??

不是很明白,跟这个有什么区别呢?请指教

  1. #include <stdio.h>;

  2. void callback( )
  3. {
  4.    printf( "Hello World!\n" );
  5. }

  6. void main( )
  7. {
  8.    callback();
  9. }
复制代码

论坛徽章:
0
发表于 2004-04-16 22:31 |显示全部楼层

谁能举一个简单的回调函数的例子啊??

要问为什么的话,就请贴主说话吧,碰到什么了让你需要了解这个呢?

论坛徽章:
0
发表于 2004-04-16 22:41 |显示全部楼层

谁能举一个简单的回调函数的例子啊??

回调可以用于支持范式编程,比如用c来做面向对象的开发时,就可以用回调的方式.

这个我自己也在研究中,写了个hash表的,贴出来,欢迎大家指正(用gcc调试)
hash.h

  1. typedef struct hash_item hash_item;
  2. struct hash_item {
  3.         void           *key;
  4.         void           *data;
  5.         hash_item      *next;
  6. };

  7. typedef struct hashing hashing;
  8. struct hashing {
  9.         int             length;
  10.         hash_item     **list;

  11.         int             (*hash_fun) (void *);
  12.         int             (*key_cmp) (void *, void *);
  13.         hash_item      *(*item_copy) (hash_item *);

  14.         hashing        *(*hash_add) (hashing *, hash_item *);
  15.         hash_item      *(*hash_get) (hashing *, void *);

  16. };

  17. extern hashing *
  18. init_hash(
  19.           hashing *,
  20.           int length,
  21.           int (*) (void *),
  22.           int (*) (void *, void *),
  23.           hash_item * (*) (hash_item *)
  24. );
  25.         extern int      str_hash_fun(void *, int);
  26.         extern int      str_hash_key_cmp(void *, void *);
  27.         extern hashing *hash_add(hashing * self, hash_item *);
  28.         extern hash_item *hash_get(hashing * self, void *);

复制代码


hash.c

  1. #include <stdio.h>;
  2. #include <string.h>;
  3. #include <assert.h>;
  4. #include "hash.h"


  5. extern int      str_hash_fun(void *, int);
  6. extern int      str_hash_key_cmp(void *, void *);
  7. extern hashing *hash_add(hashing * self, hash_item *);
  8. extern hash_item *hash_get(hashing * self, void *);


  9. extern hashing *
  10. init_hash(
  11.           hashing * self,
  12.           int length,
  13.           int (*hash_fun) (void *),
  14.           int (*key_cmp) (void *, void *),
  15.           hash_item * (*item_copy) (hash_item *)
  16. )
  17. {
  18.         int             i;

  19.         assert(length >;= 2);
  20.         assert(hash_fun != NULL);
  21.         assert(key_cmp != NULL);
  22.         assert(item_copy != NULL);

  23.         self->;list = (hash_item **) malloc(length * sizeof(hash_item *));
  24.         for (i = 0; i < length; i++) {
  25.                 self->;list[i] = NULL;
  26.         }
  27.         self->;length = length;
  28.         self->;hash_fun = hash_fun;
  29.         self->;key_cmp = key_cmp;
  30.         self->;item_copy = item_copy;

  31.         self->;hash_add = hash_add;
  32.         self->;hash_get = hash_get;
  33.         return self;
  34. }

  35. extern hashing *
  36. hash_add(hashing * self, hash_item * item)
  37. {
  38.         int             h;
  39.         hash_item      *p, *new_item;

  40.         assert(self != NULL && item != NULL);

  41.         h = self->;hash_fun(item->;key);
  42.         assert(h < self->;length);
  43.         new_item = self->;item_copy(item);
  44.         new_item->;next = NULL;
  45.         p = self->;list[h];
  46.         if (p == NULL) {
  47.                 self->;list[h] = new_item;
  48.         } else {
  49.                 while (p->;next != NULL) {
  50.                         p = p->;next;
  51.                 }
  52.                 p->;next = new_item;
  53.         }
  54.         return self;
  55. }

  56. extern hash_item *
  57. hash_get(hashing * self, void *key)
  58. {
  59.         int             h;
  60.         hash_item      *p;

  61.         assert(self != NULL && key != NULL);

  62.         h = self->;hash_fun(key);
  63.         assert(h < self->;length);
  64.         p = self->;list[h];

  65.         /* p!=NULL && key_cmp(p->;key)  can't reserve */
  66.         while (p != NULL && self->;key_cmp(p->;key, key)) {
  67.                 p = p->;next;
  68.         }
  69.         if (p == NULL) {
  70.                 return NULL;
  71.         }
  72.         return p;

  73. }

  74. extern int
  75. str_hash_fun(void *key, int length)
  76. {
  77.         int             h, l, i;
  78.         char           *str_key;

  79.         assert(key != NULL && length >; 1);

  80.         str_key = (char *)key;
  81.         l = strlen(str_key);
  82.         h = 0;
  83.         for (i = 0; i < l; i++) {
  84.                 h = (h + str_key[i]) % length;
  85.         }
  86.         return h;
  87. }

复制代码



hash_test.c

  1. #include <stdio.h>;
  2. #include <string.h>;
  3. #include <assert.h>;
  4. #include "hash.h"

  5. #define LIST_LEN        47

  6. int my_hash_fun(void *key)
  7. {
  8.         assert(key!=NULL);
  9.         return str_hash_fun(key, LIST_LEN);
  10. }

  11. int        str_hash_key_cmp(void * key1, void * key2)
  12. {
  13.         assert(key1!=NULL && key2 != NULL);
  14.         return strcmp(key1,key2);
  15. }

  16. hash_item *        my_item_copy(hash_item * x)
  17. {
  18.         hash_item * y;
  19.        
  20.         assert(x!=NULL);
  21.        
  22.         y = (hash_item *)malloc(sizeof(hash_item));
  23.         assert(y != NULL);
  24.         y->;key = strdup((char*)x->;key);
  25.         y->;data = (int *)malloc(sizeof(int));
  26.         *((int *)(y->;data)) = *((int *)(x->;data));
  27.         y->;next = NULL;
  28.         return y;
  29. }
  30.        
  31. #define        STRS        10

  32. char * my_strs[STRS] = {
  33.                 "hello", "go", "to", "pig", "dog",
  34.                 "pear", "apple", "nut", "bananer", "orange"
  35.         };

  36. #define STRC        4

  37. char *co_strs[STRC] = {
  38.                 "apple", "bananer", "pig", "go"
  39.         };

  40. main()
  41. {
  42.         int i, k;
  43.         hash_item M, *item_p;
  44.         hashing *hashing_p;
  45.        
  46.         hashing_p = (hashing *)malloc(sizeof(hashing));
  47.         assert(hashing_p!=NULL);
  48.        
  49.         init_hash(hashing_p, LIST_LEN, my_hash_fun, str_hash_key_cmp, my_item_copy);
  50.        
  51.         M.data = (int *)malloc(sizeof(int));
  52.         for(item_p = &M, i = 0; i < STRS; i++)
  53.         {
  54.                 fprintf(stdout, "%s is the No.  %d in list, No. %d item\n", my_strs[i], my_hash_fun(my_strs[i]), i);
  55.                 item_p->;key = my_strs[i];
  56.                 *((int *)(item_p->;data)) = i;
  57.                 hashing_p->;hash_add(hashing_p, item_p);
  58.         }
  59.         fprintf(stdout, "\n init end\n\ncheck out date\n");
  60.         for(i = 0; i<STRC; i++)
  61.         {
  62.                 item_p = hashing_p->;hash_get(hashing_p, co_strs[i]);
  63.                 assert(item_p!=NULL);
  64.                 k = *((int *)(item_p->;data));
  65.                 fprintf(stdout, " %s is the No. %d item\n", co_strs[i], k );
  66.                 fprintf(stdout, "item_p =  %p\n",item_p);
  67.         }
  68.        
  69.         return 0;
  70. }

复制代码

论坛徽章:
0
发表于 2011-03-23 15:36 |显示全部楼层
回复 5# hoxide


    写这么多,看死啊,我头晕。

论坛徽章:
1
2015年迎新春徽章
日期:2015-03-04 09:56:11
发表于 2011-03-23 15:59 |显示全部楼层
就是處理的部分可以設置一個函數指針,在適當的時候調用呢。

论坛徽章:
0
发表于 2011-03-23 16:29 |显示全部楼层
Windows下设置定时器的API就是一个使用回调函数的很经典的例子:
UINT_PTR SetTimer(HWND hWnd, UINT_PTR nIDEvent,  UINT uElapse, TIMERPROC lpTimerFunc);
最后一个参数就是由系统所去调用的函数,其实现由你自己指定,作用就是规定定时器到点后干什么事。
这个回调函数的形式只要符合如下规范即可:
void CALLBACK TimerProc(HWND hWnd,UINT nMsg,UINT nTimerid,DWORD dwTime);

SetTimer之后,TimerProc这个函数你永远都不会自己去显式调用,而是每隔一段时间(uElapse)由系统去调用。这也就是“回调”这个名称的含义所在了:你调用系统的函数SetTimer设置定时器,并指定处理函数入口地址;到点后系统再回过头来调用你所指定的函数。

如果说用处,个人的经验是使用回调函数可以很方便地实现异步通信,极大地提升效率。比如Winsock I/O下的重叠I/O模式(完成例程),就使用了回调的方式管理套接字。
您需要登录后才可以回帖 登录 | 注册

本版积分规则 发表回复

  

北京盛拓优讯信息技术有限公司. 版权所有 京ICP备16024965号-6 北京市公安局海淀分局网监中心备案编号:11010802020122 niuxiaotong@pcpop.com 17352615567
未成年举报专区
中国互联网协会会员  联系我们:huangweiwei@itpub.net
感谢所有关心和支持过ChinaUnix的朋友们 转载本站内容请注明原作者名及出处

清除 Cookies - ChinaUnix - Archiver - WAP - TOP