C++观察者与事件系统

C++观察者与事件系统

观察者模式定义一对多依赖，当一个对象状态变化时，所有依赖对象自动收到通知。这是事件驱动系统的核心模式。

基本观察者模式包含主题和观察者接口。

#include
#include
#include
#include
#include
#include

class Observer {
public:
virtual ~Observer() = default;
virtual void on_notify(const std::string& event, const std::string& data) = 0;
virtual int id() const = 0;
};

class Subject {
std::vector> observers_;
public:
void attach(std::shared_ptr obs) {
observers_.push_back(obs);
std::cout << "Observer " << obs->id() << " attached\n";
}

void detach(std::shared_ptr obs) {
auto it = std::find_if(observers_.begin(), observers_.end(),
[&obs](const auto& o) { return o->id() == obs->id(); });
if (it != observers_.end()) {
observers_.erase(it);
}
}

void notify(const std::string& event, const std::string& data) {
for (auto& obs : observers_) {
obs->on_notify(event, data);
}
}
};

class ConcreteObserver : public Observer {
int id_;
std::string name_;
public:
ConcreteObserver(int id, const std::string& name) : id_(id), name_(name) {}

void on_notify(const std::string& event, const std::string& data) override {
std::cout << "Observer " << name_ << " (ID:" << id_ << "): "
<< "Event='" << event << "', Data='" << data << "'\n";
}

int id() const override { return id_; }
};

void observer_demo() {
Subject subject;

auto obs1 = std::make_shared(1, "Logger");
auto obs2 = std::make_shared(2, "Display");

subject.attach(obs1);
subject.attach(obs2);

subject.notify("data_changed", "Hello World");
subject.detach(obs2);
subject.notify("update", "After detach");
}

带事件过滤的观察者系统。

enum class EventType {
ALL = 0,
DATA_CHANGE,
ERROR,
STATUS
};

class FilteredObserver : public Observer {
int id_;
std::string name_;
std::vector subscribed_events_;
public:
FilteredObserver(int id, const std::string& name, std::vector events)
: id_(id), name_(name), subscribed_events_(events) {}

void on_notify(const std::string& event, const std::string& data) override {
std::cout << "Filtered " << name_ << ": " << event << " - " << data << "\n";
}

int id() const override { return id_; }

bool is_interested(EventType type) const {
if (subscribed_events_.empty()) return true;
return std::find(subscribed_events_.begin(), subscribed_events_.end(), type)
!= subscribed_events_.end();
}
};

基于回调的事件系统。

class EventEmitter {
std::vector> listeners_;
public:
void add_listener(std::function listener) {
listeners_.push_back(std::move(listener));
}

void emit(const std::string& event, int value) {
for (auto& listener : listeners_) {
listener(event, value);
}
}
};

void callback_event_demo() {
EventEmitter emitter;

emitter.add_listener([](const std::string& evt, int val) {
std::cout << "Listener 1: " << evt << " = " << val << "\n";
});

int total = 0;
emitter.add_listener([&total](const std::string& evt, int val) {
total += val;
std::cout << "Listener 2: total = " << total << "\n";
});

emitter.emit("click", 10);
emitter.emit("scroll", 20);
}

可断开的连接。

class Connection {
std::function disconnect_fn_;
public:
Connection() = default;
explicit Connection(std::function fn) : disconnect_fn_(std::move(fn)) {}

void disconnect() {
if (disconnect_fn_) {
disconnect_fn_();
disconnect_fn_ = nullptr;
}
}

Connection(Connection&& other) noexcept
: disconnect_fn_(std::move(other.disconnect_fn_)) {}
};

class DisconnectableEmitter {
std::map> slots_;
int next_id_ = 0;
public:
Connection connect(std::function slot) {
int id = next_id_++;
slots_[id] = std::move(slot);
return Connection([this, id]() { slots_.erase(id); });
}

void emit(int value) {
for (auto& [id, slot] : slots_) {
slot(value);
}
}
};

void disconnectable_demo() {
DisconnectableEmitter emitter;

auto conn1 = emitter.connect([](int v) {
std::cout << "Slot 1: " << v << "\n";
});

auto conn2 = emitter.connect([](int v) {
std::cout << "Slot 2: " << v * 2 << "\n";
});

emitter.emit(10);
conn1.disconnect();
emitter.emit(20);
}

观察者模式是MVC架构和事件驱动系统的基础。