CFSDN坚持开源创造价值，我们致力于搭建一个资源共享平台，让每一个IT人在这里找到属于你的精彩世界.

这篇CFSDN的博客文章C++模拟实现Qt的信号与槽机制由作者收集整理，如果你对这篇文章有兴趣，记得点赞哟.

对于大多学习Qt的朋友，心中都有种好奇——那就是Qt最核心的信号与槽是如何实现的，对于小编自己也是一样，当然大家肯定都会去查阅相关资料，但大部分时候也只是一知半解，如果说要自己实现就会又摸不着头脑了;所以小编决定自己亲自用C++实现一个简单版的信号槽，来理解Qt的实现原理。于是小编就在翻阅各牛人朋友的博客和反复研究Qt源码自己重新写了一下以便交流学习.

我们先还是简单的梳理一下Qt信号与槽的实现机理：在Qt中实现信号与槽最重要的就是通过元对象系统(MOS)的元对象编译器(MOC)将我们定义的需要使用到信号与槽的类中的信号及信号调用槽函数的方法进行定义(这一步就会生成与源文件对应的moc_xx.cpp文件)，然后通过系统提供的关联方法(connect)将信号与槽建立一一对应关系，当发射信号(其实就是调用信号函数)时就会通过信号与槽的对应关系找到对应槽函数进行调用。这样的好处就是对于使用者而言不必去关心函数指针回调函数这些对于初学者比较不太容易搞清晰的东西，简化了使用者的操作。当然就像我们在享受幸福生活的时候，就一定有人在我们背后默默付出砥砺前行!这里也一样，对于我们使用者简化了操作，那为了实现这样的效果就需要在后台提供更多的支持。接下来我们就通过代码再来梳理一遍.

首先我们使用信号与槽肯定就会有信号的发送者与接收者，所以我们就先去定义这两个类对象:

1. sender.h
2. #pragma once
3. #include "object.h"
4. class Sender : public Object
5. {
6. X_OBJECT
7. public:
8. Sender(int n = 0) : m_num(n){
9. }
10. void sendSig();
11. signals:
12. void holdClass(int n);
13. int m_num;
14. };
15. sender.cpp
16. #include "sender.h"
17. void Sender::sendSig()
18. {
19. std::cout << "发送信号：holdClass" << std::endl;
20. emit holdClass(m_num);
21. }

在Qt中需要使用信号槽的对象都需要直接或间接继承一个类QObject，并且需要添加一个私有宏定义Q_OBJECT，这里就用Object和X_OBJECT代替，signals是Qt中用于声明信号函数的关键字，emit是Qt中用于发送信号定义的关键字，这里我们先假设已经有这些类和宏定义，注意信号函数是不需要我们定义的，他是在MOC预处理生成的moc_xx.cpp中自动生成定义的，所以这里的cpp很简单只有一个普通函数sendSig()的定义。同理我们再自己定义一个信号的接收者对象和其对应的槽函数.

1. receiver.h
2. #pragma once
3. #include "object.h"
4. class Receiver : public Object
5. {
6. X_OBJECT
7. public:
8. Receiver() {
9. }
10. public slots:
11. void attendClass(int n);
12. };
13. receiver.cpp
14. #include "receiver.h"
15. void Receiver::attendClass(int n)
16. {
17. std::cout << "执行槽函数attendClass：cur class " << n << std::endl;
18. }

这里的slots就是Qt中用于标识槽函数声明的关键字，槽函数是需要用户自己定义的.

然后我们就需要再将发送者信号与接收者槽关联起来，我们这就提供一个主函数来模拟关联信号与槽，让发送者产生信号:

1. main.cpp
2. #include "sender.h"
3. #include "receiver.h"
4. int main()
5. {
6. Sender xuedao(9527);
7. Receiver rjc;
8. Object::connect(&xuedao, SIGNAL(holdClass(int)), &rjc, SLOT(attendClass(int)));
9. xuedao.sendSig();
10. return 0;
11. }

这里的SIGNAL与SLOT在Qt中就是两个转换字符串的宏定义，connect是QObject的一个静态函数方法.

我们要想这个程序能正常运行起来，接下来我们就需要去定义一个类似QObject的Object类和上面需要用到的关键字与宏定义，以及模拟MOC预处理产生对应的moc_xx.cpp，里面细节的地方为了方便理解我都通过代码注释解释说明了 。

1. object.h
2. #pragma once
3. #include
4. #include
5. #include
6. #include
7. #define signals protected
8. #define slots
9. #define emit
10. #define SLOT(slt) "1"#slt // 1用于标识槽函数
11. #define SIGNAL(sig) "2"#sig //2用于标识信号
12. class Object;
13. struct MetaObject
14. {
15. //每个对象可能会有多个信号与槽函数，这里就用两个vector分别保存信号与槽函数信息操作起来方便点
16. std::vector sigs;
17. std::vector slts;
18. //activate的功能是通过信号发送者即信号索引找到关联接收者和方法索引并调用对应方法
19. static void activate(Object *sender, int idx, void **argv); //void **argv对应信号传递的参数
20. struct Connection //用于打包信号接收者与方法的索引(对应上面定义的vector中的信号槽的索引)
21. {
22. Object *m_receiver;
23. int method;
24. };
25. };
26. //Q_OBJECT宏中定义的比较多这里只选择了我们需使用的几个
27. //static MetaObject meta用于保存使用该宏定义对象中的信号与槽信号与槽的相关信息
28. //getMetaObject()用于返回发送者或接收者对象中的static MetaObject meta对象
29. #define X_OBJECT static MetaObject meta; \
30. virtual MetaObject *getMetaObject(); \
31. virtual void metaCall(int idx, void **argv); //idx为对应槽函数的索引，void**argv用于接收信号传递的参数
32. class Object //需要使用信号槽对象的公共接口对象
33. {
34. X_OBJECT
35. public:
36. virtual ~Object() {}
37. //connect用于建立信号与槽的关联信息
38. static void connect(Object *sender, const char *s1, Object *receiver, const char *s2);
39. private:
41. friend class MetaObject; //用于方便meta对象访问下面的信号槽map
42. std::multimap mp; //用于保存信号索引与接收者对象即索引的对应关系
43. //由于一个信号可以对应多个槽，同样多个信号也可以对应一个槽，所以这里选用了multimap容器做对应关系映射
44. };
46. object.cpp
47. #include "object.h"
48. #include //调用strcmp函数需要包含
49. void MetaObject::activate(Object *sender, int idx, void **argv)
50. {
51. //在信号槽对应关系的mp中找到发送者idx索引信号对应的接收者及关联方法的调用
53. auto ptr = sender->mp.equal_range(idx);
54. for(auto it = ptr.first; it != ptr.second; it++) {
55. MetaObject::Connection con = it->second;
56. con.m_receiver->metaCall(con.method, argv); //调用接收者与发送者信号关联的方法，并传递需要的参数
57. }
58. }
60. void Object::connect(Object *sender, const char *s1, Object *receiver, const char *s2)
61. {
63. int sig_idx = -1, slt_idx = -1;
64. MetaObject *senderMeta = sender->getMetaObject(); //获取发送者中保存的meta对象
65. MetaObject *receiverMeta = receiver->getMetaObject(); //获取接收中保存的meta对象
66. //比对信号名称找到对应的信号索引
68. for(int i = 0; i < senderMeta->sigs.size(); i++) {
69. if(0 == strcmp(s1+1, senderMeta->sigs[i].c_str())) {
70. sig_idx = i;
71. }
72. }
74. //这里确认是槽函数,并找到对应的槽函数索引
75. //如果有信号与信号关联的情况这里就需要去查找接收者对应的信号索引，这里省略了
76. if('1' == *s2) {
77. for(int i = 0; i < receiverMeta->slts.size(); i++) {
78. if(0 == strcmp(s2+1, receiverMeta->slts[i].c_str())) {
79. slt_idx = i;
80. }
82. }
84. }
86. if(-1 == sig_idx || -1 == slt_idx) {
88. std::cout << "no match sig or slt" << std::endl;
89. }
91. //利用multimap建立信号索引与接收者和方法索引的对应关系
92. MetaObject::Connection con = {receiver, slt_idx};
93. sender->mp.insert(std::make_pair(sig_idx, con));
94. }
96. //下面的主要是预留的方便父类调用子类重写方法的接口这里简单定义即可
97. void Object::metaCall(int idx, void **ag)
98. {
100. }
102. MetaObject Object::meta;
103. MetaObject *Object::getMetaObject()
104. {
106. return &meta;
107. }

下面就轮到MOC生成的moc_xx.cpp，这些文件在Qt中是自动生成的不需要我们实现，我这里只能手动模拟简单的实现发送者的moc_sender.cpp与接收者的moc_receiver.cpp最终我们编译程序是需要将这两个文件一起编译才能通过的.

1. moc_sender.cpp
2. #include "sender.h"
3. //根据定义的信号槽顺序将信号与槽函数名称进行保存，Qt中会将函数名称参数分开保存处理，这里简单模拟以下就好
4. static const char *sigs_name[] = {"holdClass(int)"};
5. static const char *slts_name[] = {nullptr}; //空表示当前没有定义对应的函数
6. static std::vector sigs(sigs_name, sigs_name+1);
7. static std::vector slts;
8. MetaObject Sender::meta = {sigs, slts};
9. //Sender的信号定义
10. void Sender::holdClass(int n)
11. {
12. void *arg[] = {(void *)&n};
13. //调用MetaObject的静态方法activate传递当前的信号发送者对象、信号索引及参数
14. MetaObject::activate(this, 0, arg); //0表示当前信号函数在sigs_name[]中的索引
15. }
16. MetaObject *Sender::getMetaObject()
17. {
18. return &meta; //返回Sender的meta对象
19. }
20. void Sender::metaCall(int idx, void **arg)
21. {
22. // 我们这里Sender 中没有槽函数所以这里没任何操作
23. }
24. moc_receiver.cpp
25. #include "receiver.h"
26. static const char *sigs_name[] = {nullptr};
27. static const char *slts_name[] = {"attendClass(int)"};
28. static std::vector sigs;
29. static std::vector slts(slts_name, slts_name+1);
30. MetaObject Receiver::meta = {sigs, slts};
31. MetaObject *Receiver::getMetaObject()
32. {
33. return &meta; //返回Receiver的meta对象
34. }
35. void Receiver::metaCall(int idx, void **arg)
36. {
37. //这里根据slts_name[]中的索引值调用对应的槽函数
38. if(0 == idx) {
39. int n = *((int *)arg[0]);
40. attendClass(n);
41. }
42. }

有了上面这些文件最后我们只需要将所有的.cpp文件一起编译运行就可以实现Qt中信号与槽的效果了

1. g++ object.cpp sender.cpp receiver.cpp moc_sender.cpp moc_receiver.cpp main.cpp -o xuedao

也可用其他可使用的编译器编译进行编译，这里直接用的g++.

另外如果某个对象修改或增删了信号或槽就需要去手动修改对应的moc_xx.cpp文件即可，Qt中实现考虑的实际问题会更多，这里只是把整个信号槽关联及调用流程框架进行了梳理，具体的大家可以参考Qt源码做深入学习.

原文地址：https://www.toutiao.com/a7044711173396218379/ 。

最后此篇关于C++模拟实现Qt的信号与槽机制的文章就讲到这里了,如果你想了解更多关于C++模拟实现Qt的信号与槽机制的内容请搜索CFSDN的文章或继续浏览相关文章，希望大家以后支持我的博客！ 。