Qt信号与槽

Posted on Symbols count in article: 3.9k Reading time ≈ 4 mins.

Qt的信号与槽机制是如何实现的？

猜测1：回调函数

  • 这里用C11出现的function来封装所有可调用的对象：函数、指针、lambda、bind创建的对象、重载了小括号的仿函数
  • 通过unordered_multimap来记录某个字符串与一个可调用对象的映射（注意unordered_multimap未实现[]和at函数，不能通过这类方式获取value）
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
class Connection {
    unordered_multimap<string, function<void()>> mmap;
public:
    // 按照名称建立映射关系
    void connect(const string& name, const function<void()>& callback) {
        //mmap[name] = callback; ERROR
        mmap.insert({ name, callback });
    }
    void invok(const string& name) {
        auto res = mmap.equal_range(name);
        auto l = res.first, r = res.second;
        while (l != r) {
            l->second();
            ++l;
        }
    }
};

// 全局共享的Connection
static Connection con;

class Tom {
public:
    void miaow() {
        cout << "喵" << endl;
        con.invok("mouse");
    }
};

class Jerry {
public:
    Jerry() {
        // 普通类函数的第一个参数是this，所以这里绑定this
        con.connect("mouse", bind(&Jerry::RunAway, this));
    }
    void RunAway() {
        cout << "那只笨又猫来了，快跑！" << endl;
    }
};

int main() {
    // 模拟嵌套层级很深的场景，外部不能直接访问到tom
    struct A {
        struct B {
            struct C {
            private:
                Tom tom;
            public:
                void MiaoMiaoMiao() {
                    tom.miaow();
                }
            } c;
            void MiaoMiao() {
                c.MiaoMiaoMiao();
            }
        } b;
        void Miao() {
            b.MiaoMiao();
        }
    } a;

    // 模拟嵌套层级很深的场景，外部不能直接访问到jerry
    struct D {
        struct E {
            struct F {
            private:
                Jerry jerry1, jerry2, jerry3;
            } f;
        } e;
    } d;

    a.Miao();
}

输出结果： 

1
2
3
4
喵
那只笨又猫来了，快跑！
那只笨又猫来了，快跑！
那只笨又猫来了，快跑！

猜测2：观察者模式

  • 别名：订阅-发布模式
  • 任意类继承Subject模板类，提供观察者参数，即拥有了订阅-发布模式
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
template<typename ObserverType>
class Subject {
    vector<ObserverType*> _list;
public:
    // 订阅
    void subscribe(ObserverType* obs) {
        auto itor = std::find(_list.begin(), _list.end(), obs);
        if (_list.end() == itor) {
            _list.push_back(obs);
        }
    }
    
    // 取消订阅
    void unSubscribe(ObserverType* obs) {
        // erase配合remove
        _list.erase(std::remove(_list.begin(), _list.end(), obs));
    }

    // 发布
    template<typename FuncType>
    void publish(FuncType func) {
        for (auto obs : _list) {
            // 调用回调函数，将obs作为一个参数传入
            func(obs);
        }
    }
};

// CatObserver接口 猫的观察者
class CatObserver {
public:
    virtual void onMiaow() = 0;
    virtual ~CatObserver() {}
};

// Tom继承自Subject，模板参数CatObserver
// 这样Tom就可以订阅、发布对应类型
class Tom : public Subject<CatObserver> {
public:
    void miaow() {
        cout << "喵" << endl;
        // 这里CatObserver的成员函数，所以第一个参数需要this指针，这里悬置->对应publish的object
        publish(std::bind(&CatObserver::onMiaow, std::placeholders::_1));
    }
};

// Jerry继承自CatObserver，可以被订阅
class Jerry : public CatObserver {
public:
    void onMiaow() override {
        RunAway();
    }
    void RunAway() {
        cout << "那只笨又猫来了，快跑！" << endl;
    }
};

int main() {
    Tom tom;
    Jerry jerry1, jerry2, jerry3;

    // 拿一堆jerry去订阅tom的 猫叫 事件
    tom.subscribe(&jerry1);
    tom.subscribe(&jerry2);
    tom.subscribe(&jerry3);
    
    tom.miaow();
}

输出结果： 

1
2
3
4
喵
那只笨又猫来了，快跑！
那只笨又猫来了，快跑！
那只笨又猫来了，快跑！

真实的Qt信号与槽

  • 同线程：类似函数调用，比观察者模式多一点性能损失
  • 异线程：发送者线程将槽函数的调用转化为一次“调用事件”加入到事件循环中，接收者线程执行到下一个事件处理时，处理调用事件

信号与槽借助一个工具：元对象编译器MOC（Meta Object Compiler），集成在Qt编译工具链qmake中，在编译Qt工程前会先执行MOC，解析signals、slot、emit等关键字，处理Q_OBJECT、Q_PROPERTY、Q_INVOKABLE等宏，生成一个moc_xxx.cpp的C++文件（黑魔法来实现语法糖）比如信号只要声明不用实现，因为MOC自动生成实现放在moc_xxx.cpp中。之后即可进行常规的C/C++编译、链接流程

MOC的本质：反射 反射简单来说，就是运行过程中，获取对象的构造函数、成员函数、成员变量，例如：

1
2
3
4
5
6
7
8
9
10
11
12
class Tom {
public:
    Tom() {}
    const std::string & getName() const {
        return m_name;
    }
    void setName(const std::string &name) {
        m_name = name;
    }
private:
    std::string m_name;
};

类的使用者看不到类的声明，头文件都拿不到，不能直接调用类的构造函数、成员函数。因此将Tom类的构造函数、成员函数等信息存储起来，还要能够被调用到。这些信息就是“元信息”，使用者通过“元信息”就可以“使用这个类了”，这便是反射。设计模式中的工厂模式就是反射的一种。

python中涉及反射机制的函数有：getattr(), setattr(), delattr(), exec(), eval(), __import__等，都可以执行字符串

更具体的实现机制参考窥探信号槽的实现细节，这里仅摘录部分。

参考