Cpp 练习——模仿Qt的信号槽

基本概念

首先定义如下的概念：

接收元件：Receiver<Y,Ym>
发送元件：Sender<Ym>
接收者：拥有至少一个接受元（公开成员）的类
发送者：拥有至少一个发送元件（公开成员）的类
中转者：既是发送者也是接收者的类

其中：Ym是信息类型, Y是接收者类型，接收元件和发送元件必须使用同样的信息类型Ym, 才能建立联系进行信息传递。

信息会从建立连接的发送元件传递到接收元件，发送元件和接收元件之间可以是一对多或多对多地建议联系。

具体说明

元件之间的连接

发送元件和接收元件之间的连接是双向且对等的（与QT的信号和槽函数机制不同），它们都可以与对方绑定与解绑（一对多，多对多）

sender.bind(receiver); // 发送元件可以绑定接收元件
sender.unbind(receiver); // 发送元件可以解绑接收元件
sender.unbind_all(); // 发送元件可以解绑所有的接收元件, 在析构时会自动调用

receiver.bind(sender); // 接收元件可以绑定发送元件
receiver.unbind(sender); // 接收元件可以解绑发送元件
receiver.unbind_all(); // 接收元件可以解绑所有的发送元件, 在析构时会自动调用

在发送元件内部会维持一个与自己连接的接收元件记录列表, 可以查询自己的状态

1 2	sender.num() // 查询接收元件记录的个数 sender.is_bind(receiver) // 查询接收元件是否已被记录

对接收元件也是一样的

1
2
3

receiver.num()           // 查询发送元件记录的个数
receiver.is_bind(sender) // 查询发送元件是否已被记录
receiver.is_init()       // 查询现在是否已经初始化

发送者的发送行为

创建信息message
在自己的方法内部主动调用发送元件的sender.exec(message)方法，将消息发送出去

例如

class TestSender {
    std::string m_name;

public:
    MSender<int> int_sender_kernel;

    explicit TestSender(const std::string &name): m_name(name) {
        int_sender_kernel.name(nullptr);
    }

    // 调用发送元件来发送信息
    void emit(int m) {
        int_sender_kernel.exec(m);
    }
};

接收者的接收行为

接收者在构造函数中需要调用init方法初始化接受元，将接收者的指针X和指定的公开方法指针Y传递给它。然后接收元件在收到消息后，就可以正确调用接收者的指定的公开方法，否则无效但不会报错，只是消息丢失了。

1	receiver.init(X,Y)

例如

class TestReceiver {
    std::string m_name;

public:
    MReceiver<TestReceiver, int> int_receiver_kernel;  // 接收元件

    explicit TestReceiver(const std::string &name): m_name(name) {
        // 把接收元件绑定到接收者自身和自身的方法
        int_receiver_kernel.init(this, &TestReceiver::method);
    }

    void method(int m) {
        // 接受元会自动调用这个方法
        std::cout << "     " << m_the_name << " receive " << m << " ("
                  << int_receiver_kernel.num() << ")\n";
    }
};

补充说明

为了让消息传递过程可视化，支持给发送元件和接收元件指定名称，

1 2	sender.name(name_str) receiver.name(name_str)

如果设置了, 则在传递消息时会首先把名称字符串传递给std::cout，可以传入一个nullptr用来移除名称字符串。

不要使用detail_开头的接口, 这是不合适的操作, 但又不方便设置私有权限，可能导致指针和析构的错误。

源码

实现代码如下

signal.hpp

#pragma once

#include <iostream>
#include <list>

// 基于std::list在发送元和接收元内部记录链表

// 把两个基类放置在m_signal子命名空间
// MSender和MReceiver放置在m_signal命名空间
// 使用bind和unbind两个方法进行绑定和解绑, 发送元和接收元都可以发起, 而且等价

namespace m_signal {

// 接收元基类的声明前置, 因为两个基类存在相互的调用关系

template <typename Ym>
class MReceiverBase;

// 发送元基类
// 需要使用接收元基类指针作为参数
template <typename Ym>
class MSenderBase {
public:
    virtual ~MSenderBase() = default;

    virtual void exec(Ym message) const = 0;  // 发送行为

    // 这两个也需要被接收元调用，因此首先在基类中定义

    virtual bool
    detail_sender_append(MReceiverBase<Ym> *receiver) = 0;  // 保存接收元记录
    virtual bool
    detail_sender_remove(MReceiverBase<Ym> *receiver) = 0;  // 删除接收元记录
};

// 接收元基类
// 需要使用发送元基类指针作为参数
template <typename Ym>
class MReceiverBase {
public:
    virtual ~MReceiverBase() = default;

    virtual void exec(Ym message) const = 0;  // 接收行为

    // 这两个也需要被发送元调用，因此首先在基类中定义

    virtual bool
    detail_receiver_append(MSenderBase<Ym> *) = 0;  // 保存发送元记录
    virtual bool
    detail_receiver_remove(MSenderBase<Ym> *) = 0;  // 删除发送元记录
};

}  // namespace m_signal

// 前置声明
template <typename Ym>
class MSender;

// 接收元
// Y 接收者类型 Ym 信息类型
template <typename Y, typename Ym>
class MReceiver final : public m_signal::MReceiverBase<Ym> {
private:
    Y *m_the_receiver = nullptr;          // 接收者指针
    void (Y::*m_the_func)(Ym) = nullptr;  // 接收者将要调用的方法指针

    std::list<m_signal::MSenderBase<Ym> *> m_the_senders;  // 发送元记录

    const char *m_the_name = nullptr;  // 名称字符串

public:
    // 默认构造函数
    MReceiver() = default;

    MReceiver(const MReceiver &) = delete;
    MReceiver &operator=(const MReceiver &) = delete;

    // 自带初始化的构造函数
    MReceiver(Y *receiver, void (Y::*func)(Ym))
        : m_the_receiver(receiver), m_the_func(func) {}

    // 接收元的初始化
    void init(Y *receiver, void (Y::*func)(Ym)) {
        m_the_receiver = receiver;
        m_the_func = func;
    }

    // 添加名称字符串, 会在exec的开头自动调用
    void name(const char *name_str) { m_the_name = name_str; }

    // 接收行为
    // 被发送元的发送行为主动调用
    void exec(Ym message) const {
        if (m_the_name != nullptr) std::cout << m_the_name;

        // 只有在初始化完成的情况下, 才会调用; 否则空指针不会调用
        if (m_the_receiver && m_the_func) {
            (m_the_receiver->*m_the_func)(message);
        }
    }

    // 解绑全部, 析构会自动调用
    // 通知所有记录的发送元调用sender_remove方法, 删除这个接收元记录
    void detail_receiver_unbind_all() {
        auto it = m_the_senders.begin();
        while (it != m_the_senders.end()) {
            (*it)->detail_sender_remove(this);
            it = m_the_senders.erase(it);
        }
    }

    // 接收元析构
    ~MReceiver() { detail_receiver_unbind_all(); }

    // 保存发送元记录
    bool detail_receiver_append(m_signal::MSenderBase<Ym> *sender) {
        auto it = m_the_senders.begin();
        while (it != m_the_senders.end()) {
            if (*it == sender) {  // 发送元已存在
                return false;
            }
            ++it;
        }

        m_the_senders.push_back(sender);  // 保存发送元记录
        return true;
    }

    // 删除发送元记录
    bool detail_receiver_remove(m_signal::MSenderBase<Ym> *sender) {
        auto it = m_the_senders.begin();
        while (it != m_the_senders.end()) {
            if (*it == sender) {
                it = m_the_senders.erase(it);  // 删除发送元记录
                return true;
            }
            ++it;
        }
        return false;  // 发送元不存在
    }

    // 绑定发送元
    void detail_receiver_bind(m_signal::MSenderBase<Ym> *sender) {
        if (detail_receiver_append(sender)) {
            sender->detail_sender_append(this);  // 添加新的发送元时, 通知发送元
        }
    }

    // 解绑发送元
    void detail_receiver_unbind(m_signal::MSenderBase<Ym> *sender) {
        if (detail_receiver_remove(sender)) {
            sender->detail_sender_remove(
                this);  // 删除已有的发送元时, 通知发送元
        }
    }

    // 更实用的接口

    // 绑定, 转换指针为基类指针
    void bind(MSender<Ym> *sender) {
        detail_receiver_bind(static_cast<m_signal::MSenderBase<Ym> *>(sender));
    }

    // 解绑, 转换指针为基类指针
    void unbind(MSender<Ym> *sender) {
        detail_receiver_unbind(
            static_cast<m_signal::MSenderBase<Ym> *>(sender));
    }

    // 解绑所有的发送元
    void unbind_all() { detail_receiver_unbind_all(); }

    // 查询发送元记录
    bool is_bind(m_signal::MSenderBase<Ym> *sender) const {
        auto it = m_the_senders.begin();
        while (it != m_the_senders.end()) {
            if (*it == sender) {  // 发送元已存在
                return true;
            }
            ++it;
        }

        return false;  // 发送元不存在
    }

    // 查询接收元记录的个数
    size_t num() const { return m_the_senders.size(); }

    // 查询接收元是否被正确地初始化
    bool is_init() const {
        return static_cast<bool>(m_the_receiver && m_the_func);
    }
};

// 发送元
// Ym 信息类型
template <typename Ym>
class MSender final : public m_signal::MSenderBase<Ym> {
private:
    std::list<m_signal::MReceiverBase<Ym> *> m_the_receivers;  // 接收元记录

    const char *m_the_name = nullptr;  // 名称字符串

public:
    // 默认构造函数
    MSender() = default;

    MSender(const MSender &) = delete;
    MSender &operator=(const MSender &) = delete;

    // 添加名称字符串, 会在exec的开头自动调用
    void name(const char *name_str) { m_the_name = name_str; }

    // 发送行为
    // 遍历所有接收元记录, 依次触发接收元的接收行为, 传递信息
    void exec(Ym message) const {
        if (m_the_name != nullptr) std::cout << m_the_name;

        auto it = m_the_receivers.begin();
        while (it != m_the_receivers.end()) {
            (*it)->exec(message);
            ++it;
        }
    }

    // 解绑全部, 析构会自动调用
    // 通知所有记录的的接收元调用receiver_remove方法, 删除这个发送元记录
    void detail_sender_unbind_all() {
        auto it = m_the_receivers.begin();
        while (it != m_the_receivers.end()) {
            (*it)->detail_receiver_remove(this);
            it = m_the_receivers.erase(it);
        }
    }

    // 发送元析构
    ~MSender() { detail_sender_unbind_all(); }

    // 保存接收元记录
    bool detail_sender_append(m_signal::MReceiverBase<Ym> *receiver) {
        auto it = m_the_receivers.begin();
        while (it != m_the_receivers.end()) {
            if (*it == receiver) {  // 接收元已存在
                return false;
            }
            ++it;
        }

        m_the_receivers.push_back(receiver);  // 保存接收元记录
        return true;
    }

    // 删除接收元记录
    bool detail_sender_remove(m_signal::MReceiverBase<Ym> *receiver) {
        auto it = m_the_receivers.begin();
        while (it != m_the_receivers.end()) {
            if (*it == receiver) {
                it = m_the_receivers.erase(it);  // 删除接收元记录
                return true;
            }
            ++it;
        }
        return false;  // 接收元不存在
    }

    // 绑定接收元
    void detail_sender_bind(m_signal::MReceiverBase<Ym> *receiver) {
        if (detail_sender_append(receiver)) {
            receiver->detail_receiver_append(
                this);  // 添加新的接收元时, 通知接收元
        }
    }

    // 解绑接收元
    void detail_sender_unbind(m_signal::MReceiverBase<Ym> *receiver) {
        if (detail_sender_remove(receiver)) {
            receiver->detail_receiver_remove(
                this);  // 删除已有的接收元时, 通知接收元
        }
    }

    // 更实用的接口

    // 绑定, 转换指针为基类指针
    template <typename Y>
    void bind(MReceiver<Y, Ym> *receiver) {
        detail_sender_bind(
            static_cast<m_signal::MReceiverBase<Ym> *>(receiver));
    }

    // 解绑, 转换指针为基类指针
    template <typename Y>
    void unbind(MReceiver<Y, Ym> *receiver) {
        detail_sender_unbind(
            static_cast<m_signal::MReceiverBase<Ym> *>(receiver));
    }

    // 解绑所有的接收元
    void unbind_all() { detail_sender_unbind_all(); }

    // 查询接收元记录
    bool is_bind(m_signal::MReceiverBase<Ym> *receiver) const {
        auto it = m_the_receivers.begin();
        while (it != m_the_receivers.end()) {
            if (*it == receiver) {  // 接收元已存在
                return true;
            }
            ++it;
        }

        return false;  // 接收元不存在
    }

    // 查询接收元记录的个数
    size_t num() const { return m_the_receivers.size(); }
};

测试代码以及运行结果如下

// main.cpp
#include <string>

#include "signal.hpp"

// 具体的接收者
class TestReceiver {
    std::string m_the_name;

public:
    MReceiver<TestReceiver, int> int_receiver_kernel;  // 接收元
    MSender<int> int_sender_kernel;                    // 发送元

    explicit TestReceiver(const char *name) {
        m_the_name = std::string(name);
        // 把接收元绑定接收者自身和自身的方法
        int_receiver_kernel.init(this, &TestReceiver::method);
    }

    // receiver_exec会调用这个方法
    void method(int m) {
        std::cout << "     " << m_the_name << " receive " << m << " ("
                  << int_receiver_kernel.num() << ")\n";

        if (int_sender_kernel.num() > 0) { emit(m); }
    }

    void emit(int m) {
        std::cout << m_the_name << " send " << m << ": ("
                  << int_sender_kernel.num() << ")\n";

        int_sender_kernel.exec(m);
    }
};

// 具体的发送者
class TestSender {
    std::string m_the_name;

public:
    MSender<int> int_sender_kernel;

    explicit TestSender(const char *name) {
        m_the_name = std::string(name);
        int_sender_kernel.name("TestSender int_sender_kernel\n");
        int_sender_kernel.name(nullptr);
    }

    void emit(int m) {
        std::cout << m_the_name << " send " << m << ": ("
                  << int_sender_kernel.num() << ")\n";

        int_sender_kernel.exec(m);
    }
};

int main() {
    TestSender Ada("Ada");  // 拥有一个发送元

    TestReceiver Mike("Mike");  // 拥有一个发送元和一个接收元
    TestReceiver John("John");
    TestReceiver Jack("Jack");

    Ada.int_sender_kernel.bind(&Mike.int_receiver_kernel);  // Ada-> Mike
    Ada.int_sender_kernel.bind(&John.int_receiver_kernel);  // Ada-> John

    Ada.emit(1);
    // Ada发出信号
    // -> Mike
    // -> John

    Ada.int_sender_kernel.bind(&Jack.int_receiver_kernel);   // Ada-> Jack
    Jack.int_sender_kernel.bind(&John.int_receiver_kernel);  // Jack-> John

    Ada.emit(2);
    // Ada发出信号, 都会收到, 这时John会收到两次
    // -> Mike
    // -> John
    // -> Jack
    // Jack发出信号
    // -> John

    Ada.int_sender_kernel.unbind(
        &Jack.int_receiver_kernel);  // Ada不再绑定到Jack

    Ada.emit(3);
    // Ada发出信号
    // -> Mike
    // -> John

    John.int_receiver_kernel.unbind_all();  // John的接收元解除了所有的绑定

    Ada.emit(4);
    // Ada发出信号
    // -> Mike

    return 0;
}