C++实现回调的一种方式

SproutME

1. #include <stdio.h>
   
2. 
   
3. 
   
4. class EpollInterface{
   
5. public:
   
6.     EpollInterface(){}
   
7.     virtual void epollEvent(){ printf("EpollInterface print\n");}
   
8. };
   
9. 
   
10. class Epoll : public EpollInterface{
    
11. public:
    
12.     Epoll(EpollInterface *parent){
    
13.         this->parent = parent;
    
14.     }
    
15. 
    
16.     void print(){
    
17.         printf("Epoll print!\n");
    
18.     }
    
19. 
    
20.     void epollEventHandle() {
    
21.         parent->epollEvent();
    
22.     }
    
23. 
    
24. private:
    
25.     EpollInterface *parent;
    
26. };
    
27. 
    
28. class UsrNeedEpoll : public EpollInterface{
    
29. public:
    
30.     UsrNeedEpoll() {
    
31.         usrEpoll = new Epoll(this);
    
32.     }
    
33. 
    
34.     void epollEvent() {
    
35.         printf("usrEpoll \n");
    
36.     }
    
37. 
    
38.     Epoll *usrEpoll;
    
39. };
    
40. 
    
41. 
    
42. 
    
43. int main()
    
44. {
    
45. 
    
46.     UsrNeedEpoll usr;
    
47. 
    
48.     usr.usrEpoll->epollEventHandle();
    
49.     return 0;
    
50. }
    

复制代码

转角

不要误导人，这不是回调

SproutME

转角 发表于 2015-9-16 11:08
不要误导人，这不是回调

你可以看清楚再说

转角

这真不是回调。说它是个重写还不是重写，根本就是两个类里面互相包含了个对象而已。

SproutME

转角 发表于 2015-9-16 20:58
这真不是回调。说它是个重写还不是重写，根本就是两个类里面互相包含了个对象而已。

1. //
   
2. //  main.cpp
   
3. //  Lambda
   
4. //
   
5. //  Created by Atropos on 15/9/2.
   
6. //  Copyright &#169; 2015年 Atropos. All rights reserved.
   
7. //
   
8. 
   
9. #include <iostream>
   
10. #include <string>
    
11. #include "ClassTemplate.hpp"
    
12. 
    
13. #include <pthread.h>
    
14. #include <unistd.h>
    
15. 
    
16. // 串口的事件处理接口
    
17. class Event_receive {
    
18. public:
    
19.     Event_receive() {}
    
20.    
    
21.     virtual int event(std::string str) = 0;
    
22. };
    
23. 
    
24. // 串口类定时一秒发一次；
    
25. class USART_EXAMPLE {
    
26. public:
    
27.     USART_EXAMPLE(Event_receive *ptr)
    
28.             : _usr(ptr)
    
29.     {
    
30.         pthread_create(&_pthread, NULL, task, this);
    
31.     }
    
32.    
    
33.     ~USART_EXAMPLE() {
    
34.         pthread_join(_pthread, NULL);
    
35.     }
    
36.    
    
37. private:
    
38.     // 使用者的指针用于回调接口
    
39.     Event_receive *_usr;
    
40.    
    
41.     // 线程号
    
42.     pthread_t _pthread;
    
43.    
    
44. private:
    
45.     // c调用c＋＋的转换接口
    
46.     static void * task (void * ptr) {
    
47.         USART_EXAMPLE *func = (USART_EXAMPLE *)ptr;
    
48.         
    
49.         func->taskHandle();
    
50.         return 0;
    
51.     }
    
52.     // 定时发送
    
53.     void taskHandle() {
    
54.         while (true) {
    
55.             sleep(1);
    
56.             _usr->event("123");
    
57.         }
    
58.     }
    
59. };
    
60. 
    
61. 
    
62. class Usr
    
63.     // 实现事件接口
    
64.     : public Event_receive
    
65. {
    
66. public:
    
67.     Usr() : _usart(this) {}
    
68. private:
    
69.     // 实例化一个串口
    
70.     USART_EXAMPLE _usart;
    
71.    
    
72. private:
    
73.     // 事件处理函数供串口接收调用
    
74.     virtual int event(std::string str)  {
    
75.         std::cout << str << std::endl;
    
76.         return 1;
    
77.     }
    
78. };
    
79. 
    
80. 
    
81. 
    
82. int main(int argc, const char * argv[]) {
    
83.    
    
84.     Usr usr;
    
85.     return 0;
    
86. }

复制代码

转角

姑娘啊，你这个例子可以运行是真的，可能你把回调理解错了。你这个只是创建了线程，把对象传递给线程了，并在线程里面用这个对象调用它的函数。这个逻辑可以实现你的要求，但是不能叫它为回调。

SproutME

转角 发表于 2015-9-19 17:06
姑娘啊，你这个例子可以运行是真的，可能你把回调理解错了。你这个只是创建了线程，把对象传递给线程了，并 ...

怎么就不叫回调了呢～  这个不叫callback 叫什么呢

转角

这就是普通的一个对象调用成员函数。如果你创建线程时候那个参数传递的是函数地址，线程内直接使用这个函数地址的 那叫回调。
当别人提供一个回调接口的时候他们不可能跟你约定对象类型对吧，所以只提供函数入口地址就可以了。

SproutME

转角 发表于 2015-9-20 21:50
这就是普通的一个对象调用成员函数。如果你创建线程时候那个参数传递的是函数地址，线程内直接使用这个函数 ...

成员函数做为参数传递事非常复杂的；其实最好是用闭包来做，但是这样消耗太大了～；C++不像别的语言那样有内省机制，所以这种只是一种中庸方法，利用接口来约定处理事件，这种方式在Qt中也很常见！