强大的C++事件模式

如果不是因为对象不"知道"它们的存在，您可以简单地将您想要的副作用编码到 Listener 虚拟基析构函数中，以便在它离开范围时取消注册自身。

回调 API 绝对是一个类似"C"的构造。 若要桥接到C++，需要提供实例上下文以及回调方法。 发射器 API 仅将 void* 不透明客户端上下文引用作为参数传递，因此它实际上并不"知道"或关心客户端类型，它只需要传回注册中给出的相同 void* _t。这使得 main（） 能够注册 &listener1 "this" 指针作为引用。

：getEvent（） 转换为"C"样式的静态方法，该方法接受一些 void* 指针，然后将其转换为 Listener 对象，并在处理事件之前使用它来确定对象是否存在。 一个私有的静态 std：：set 容器将便于验证。 这样可以安全地完成桥梁进入C++土地。

我在这里描述了我的解决方案：http://www.juce.com/forum/topic/signals-slots-juce#comment-321103

http://coliru.stacked-crooked.com/a/b2733e334f4a5289

#include <vector>
#include <iostream>
#include <algorithm>
#include <memory>
#include <string>
using namespace std;
// an event holds a vector of subscribers
// when it fires, each is called
template<class... Args>
class SubscriberBase {
public:
    virtual void call(Args... args) = 0;
    virtual bool instanceIs(void* t) = 0;
    virtual ~SubscriberBase() { };
};
template<class T, class... Args>
class Subscriber : public SubscriberBase<Args...> {
private:
    T* t;
    void(T::*f)(Args...);
public:
    Subscriber(T* _t, void(T::*_f)(Args...)) : t(_t), f(_f) { }
    void call(Args... args)   final { (t->*f)(args...); }
    bool instanceIs(void* _t) final { return _t == (void*)t; }
    ~Subscriber()             final { cout << "~Subscriber() hit! n"; }
};
// our Listener will derive from EventListener<Listener>
// which holds a list of a events it is subscribed to.
// As these events will have different sigs, we need a base-class.
// We will store pointers to this base-class.
class EventBase { 
public:
    virtual void removeSubscriber(void* t) = 0;
};
template<class... Args>
class Event : public EventBase {
private:
    using SmartBasePointer = unique_ptr<SubscriberBase<Args...>>;
    std::vector<SmartBasePointer> subscribers;
public:
    void fire(Args... args) {
        for (auto& f : subscribers)
            f->call(args...);
    }
    template<class T>
    void addSubscriber(T* t, void(T::*f)(Args... args)) {
        auto s = new Subscriber <T, Args...>(t, f);
        subscribers.push_back(SmartBasePointer(s));
    }
    //template<class T>
    void removeSubscriber(void* t) final {
        auto to_remove = std::remove_if(
            subscribers.begin(),
            subscribers.end(),
            [t](auto& s) { return s->instanceIs(t); }
        );
        subscribers.erase(to_remove, subscribers.end());
    }
};
// derive your listener classes: struct MyListener : EventListener<MyListener>, i.e. CRTP
template<class Derived>
class EventListener {
private:
    // all events holding a subscription to us...
    std::vector<EventBase*> events;
public:
    template<class... Args>
    void connect(Event<Args...>& ev, void(Derived::*listenerMethod)(Args... args)) {
        ev.addSubscriber((Derived*)this, listenerMethod);
        events.push_back(&ev);
    }
    // ...when the listener dies, we must notify them all to remove subscription
    ~EventListener() {
        for (auto& e : events)
            e->removeSubscriber((void*)this);
    }
};
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
// example usage:
class Publisher {
private:
    string name;
public:
    Event<float> eventFloat;
    Event<bool, int> eventB;
    Publisher(string _name) : name(_name) { }
    void triggerEvent() {
        cout << name << "::triggerEvent() ~ Firing event with: 42n";
        eventFloat.fire(42.0f);
    }
};
struct Listener : EventListener<Listener> {
    string name;
    Listener(string _name)
        : name(_name) {
        cout << name << "()n";
    }
    ~Listener() {
        cout << "~" << name << "()n";
        //emitter.eventFloat.removeSubscriber(this); 
    }
    void gotEvent(float x) { cout << name << "::gotEvent hit with value: " << x << endl; }
};
int main() {
    // event source and listener unaware of each other's existence
    Publisher publisherA("publisherA");
    Listener listener1("listener1");
    listener1.connect(publisherA.eventFloat, &Listener::gotEvent);
    {
        Listener listener2("listener2");
        listener2.connect(publisherA.eventFloat, &Listener::gotEvent);
        publisherA.triggerEvent();
    }
    publisherA.triggerEvent();
    return 0;
}