C++11 实现简易的信号槽

在Qt中对象间通讯，普遍使用了信号槽机制。Qt信号机制是经过语法扩展实现的，所以定制性更好，使用更便利。 这篇文章所实现的信号槽机制，则没有扩展语法，经过简单的模板实现。

#include <iostream>
#include <memory>
#include <string>
#include <functional>
#include <vector>
 
#define signals    public
#define slots  
 
template<typename Signature> class Signal;
 
template<typename Ret, typename... Args>
class Signal<Ret(Args...)> final
{
    using Slot = std::function<void(Args&&...)>;
public:
    Signal(){}
    
 
    void connect(const Slot &slot)
    {
        slots_.push_back(slot);
    }
 
    void emit(Args&&... args)
    {
        for(auto &slot : slots_){
            slot(std::forward<Args>(args)...);
        }
    }
private:
    std::vector<Slot> slots_;
};
 
template<typename Ret, typename Class, typename... Args>
class Signal<Ret(Class::*)(Args...)> final
{
    using Slot = std::function<void(Class::*)(Args&&...)>;
public:
    Signal(){}
    
 
    void connect(const Slot &slot)
    {
        slots_.push_back(slot);
    }
 
    void emit(Args&&... args)
    {
        for(auto &slot : slots_){
            slot(std::forward<Args>(args)...);
        }
    } 
private:
    std::vector<Slot> slots_;
};
 
//------------------------ 使用 -----------------------------------
struct Observable
{
public slots:
    void onAction1(int v)
    {
        std::cout << "action1: " << v << std::endl;
    }
    
    void onAction2(int v, const std::string &s) 
    {
        std::cout << "action2: " << v << " s: " << s << std::endl;
    }
    
    void onActionPass(int v, std::string s, double d) 
    {
        std::cout << "action2: " << v << " s: " << s << " d: " << d << std::endl;
    }
};
 
struct Observer
{
signals:        //定义信号对象，必须和槽函数参数列表一致。
    Signal<void(int)> action1;
    Signal<void(int, std::string, double)> action2;  
};
 
int main(int argc, char *argv[])
{
    
    Observer observer;
    Observable observable;
    
    //方式1  使用observer的信号对象进行链接槽函数 function。
    observer.action1.connect(std::bind(&Observable::onAction1, &observable, std::placeholders::_1));
    observer.action2.connect(std::bind(&Observable::onAction2, &observable, std::placeholders::_1, std::placeholders::_2));
    
    //方式2 使用observer的信号对象进行链接槽函数 lambda。
    observer.action1.connect([&observable](int v) { observable.onAction1(v); });   
    observer.action2.connect([&observable](int v,  std::string s, double d) { observable.onActionPass(v, s, d); });
 
    
    observer.action1.emit(10);
    observer.action2.emit(22, "hello world", 10.44);
 
    return 0;

————————————————
版权声明：本文为CSDN博主「十万个为什猫」的原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处连接及本声明。
原文连接：https://blog.csdn.net/zhiguangli123/article/details/88798961