c++ - 健壮的 C++ 事件模式

Question

我整理了一个简单的 C++ 事件模式，允许执行以下操作:

struct Emitter {
    Event<float> ev;    
    void triggerEvent() { ev.fire(42.0); }
};

struct Listener {
    void gotEvent(float x) { ... }
};

int main() {
    // event source and listener unaware of each other's existence
    Emitter emitter(); 
    Listener listener();

    // hook them up
    emitterA.ev.addSubscriber(&listener, &Listener::gotEvent);
    {
        Listener listener2();
        emitter.ev.addSubscriber(&listener2, &Listener::gotEvent);
        emitter.triggerEvent();
        emitter.ev.removeSubscriber(&listener2); 
        // ^ PROBLEM!
    }

    emitter.triggerEvent();

    emitter.ev.removeSubscriber(&listener1); 
}

问题是开发人员需要手动删除每个订阅者，否则事件的 fire() 在遍历所有订阅者时将最终触发对象上的方法，该对象可能仍然存在，也可能不存在存在。

这是完整的代码，连同一个工作示例:http://coliru.stacked-crooked.com/a/8bb20dacf50bf073

我将粘贴在下面以供后代使用。

如果我注释掉有问题的第 99 行，它仍然有效!但这显然只是因为内存还没有被覆盖。

这是一个危险的错误，因为它可能处于休眠状态。

我怎样才能以不会让我暴露于这种潜在的 UB 错误的方式进行编码？

有没有办法让我的第35行..

template<class... Args> 
class Event {
    :
    void fire(Args... args) {
        for( auto& f : subscribers )
            f->call(args...);

可以以某种方式检测每个订阅者是否仍然存在...

同时仍然保留发射器和订阅器不知道彼此存在的事实？

完整 list :

#include <vector>
#include <iostream>
#include <algorithm>
#include <memory>

using namespace std;

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"; }
};

template<class... Args> 
class Event {
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(T* t) {
        auto to_remove = std::remove_if(
            subscribers.begin(), 
            subscribers.end(),  
            [t](auto& s) { return s->instanceIs((void*)t); }
            );
        subscribers.erase(to_remove, subscribers.end()); 
    }
};

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 

// example usage:
class Emitter {
private:
    string name;
public:    
    Event<float> eventFloat;
    Event<bool, int> eventB;

    Emitter(string _name) : name(_name) { }

    void triggerEvent() { 
        cout << name << "::triggerEvent() ~ Firing event with: 42\n";
        eventFloat.fire(42.0f); 
    }
};

struct 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
    Emitter emitterA("emitterA"); 
    Listener listener1("listener1");

    // hook them up
    emitterA.eventFloat.addSubscriber(&listener1, &Listener::gotEvent);
    {
        Listener listener2("listener2");
        emitterA.eventFloat.addSubscriber(&listener2, &Listener::gotEvent);
        emitterA.triggerEvent();
        //emitterA.eventFloat.removeSubscriber(&listener2); // hmm this is awkward
    }

    emitterA.triggerEvent();

    emitterA.eventFloat.removeSubscriber(&listener1); 
    emitterA.triggerEvent();

    return 0;
}

Answer 1

如果不是因为对象不“知道”它们的存在，您可以简单地将您想要的副作用编码到 Listener 虚拟基类析构函数中，以便在它离开作用域时自行注销。

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

将 Listener::getEvent() 转换为“C”风格的静态方法，该方法接受一些 void* 指针，然后将其转换为 Listener 对象，并在处理事件之前使用它来确定对象是否存在。私有(private)的静态 std::set 容器可以方便地进行验证。这安全地完成了通往 C++ 领域的桥梁。