C++事件类回调示例

class AA{
public:
	void attach(const function<void(int)>& callback){
		m_callback = callback;
	}
	void detach(const function<void(int)>& callback){
		m_callback = function<void(int)>();
	}
	void processAsyn(){
		cout << "AA::processAsyn tid = " << this_thread::get_id() << endl;
		m_th = std::thread(&AA::threadFun, this);
		m_th.detach();
	}

private:
	void threadFun(){
		_sleep(300);
		cout << "AA::threadFun tid = " << this_thread::get_id() << endl;
		if (m_callback){
			m_callback(20);
		}
	}
	function<void(int)> m_callback;
	thread m_th;
};

class BB{
public:
	void exec(){
		cout << "BB::exec tid = " << this_thread::get_id() << endl;
		m_a = make_unique<AA>();
		m_a->attach(std::bind(&BB::onRes, this, std::placeholders::_1));
		m_a->processAsyn();
	}
	//m_b = std::make_unique<B>();
	//m_b->attachCallback(std::bind(&A::onProcessDone, this, std::placeholders::_1));
	//m_b->attachCallback([this](int res){ return onProcessDone(res); });
	//m_b->detachCallback(std::bind(&A::onProcessDone, this, std::placeholders::_1));
	//m_b->processAsyn();

private:
	void onRes(int val){
		cout << "BB::onRes tid = " << this_thread::get_id() << endl;
		cout << val << endl;
	}
	std::unique_ptr<AA> m_a{ nullptr };
};

//解耦 C++的事件驱动编程示例

#include <iostream>
#include <functional>
#include <vector>
#include <map>
#include <string>

//事件类型，functional可以涵盖仿函数、函数指针、lamda表达式
typedef std::function<void()> EventHandler;

//事件管理者类
class EventManeger{
public:
	void subscribe(const std::string& eventName, const EventHandler& handler){
		_subscribers[eventName].push_back(handler);
	}

	void publish(const std::string& eventName){
		auto it = _subscribers.find(eventName);
		if (it != _subscribers.end()){
			std::cout << "事件:" << eventName << " 发生了" << std::endl;
			for (auto& handler : it->second){
				handler();
			}
		}
		else{
			std::cout << "事件:" << eventName << " 未订阅" << std::endl;
		}
	}

private:
	std::map<std::string, std::vector<EventHandler>> _subscribers;	//订阅集合
};

//事件发生器类
class EventGenerator{
public:
	EventGenerator(EventManeger& manager) : _eventManager(manager){}
	//产生事件
	void generateEvent(const std::string& eventName){
		_eventManager.publish(eventName);
	}

private:
	EventManeger& _eventManager;
};


//订阅者类
class Subscriber{
public:
	Subscriber(const std::string& name) : _subscriberName(name){}

	void handleEvent(const std::string& eventName){
		std::cout << "订阅者:" << _subscriberName << "收到事件:" << eventName << " 且处理" << std::endl;
	}
private:
	std::string _subscriberName;
};

int main()
{
	//实例化对象
	EventManeger eventmanager;
	EventGenerator eventGenerator(eventmanager);
	Subscriber sub1("JJ");
	Subscriber sub2("KK");

	//订阅事件
	//产生照明事件，则触发sub1、sub2对应的事件处理
	eventmanager.subscribe("照明", [&](){ sub1.handleEvent("照明"); });
	eventmanager.subscribe("闪光", [&](){ sub2.handleEvent("闪光"); });
	eventmanager.subscribe("照明", [&](){ sub2.handleEvent("照明"); });

	eventGenerator.generateEvent("照明");
	eventGenerator.generateEvent("闪光");
	eventGenerator.generateEvent("hehe");

	return 0;
}

使用事件驱动编程来实现一个简单的GUI框架

#include <iostream>
#include <functional>
#include <vector>
#include <map>

// 定义事件类型
typedef std::function<void()> EventHandler;

// 事件管理器类
class EventManager {
public:
	void subscribe(const std::string& eventName, const EventHandler& handler) {
		subscribers[eventName].push_back(handler);
	}

	void publish(const std::string& eventName) {
		auto it = subscribers.find(eventName);
		if (it != subscribers.end()) {
			// 触发该事件的所有订阅者的处理函数
			for (auto& handler : it->second) {
				handler();
			}
		}
	}

private:
	std::map<std::string, std::vector<EventHandler>> subscribers;
};

// GUI组件基类
class GUIComponent {
public:
	GUIComponent(EventManager& manager) : eventManager(manager) {}

	virtual void onClick() = 0;
	virtual void onHover() = 0;
	virtual void onKeyDown() = 0;

protected:
	EventManager& eventManager;
};

// 按钮组件
class Button : public GUIComponent {
public:
	Button(EventManager& manager) : GUIComponent(manager) {}

	void onClick() override {
		std::cout << "按钮被点击了！" << std::endl;
		eventManager.publish("ButtonClickedEvent");
	}

	void onHover() override {
		std::cout << "鼠标悬停在按钮上！" << std::endl;
		eventManager.publish("ButtonHoveredEvent");
	}

	void onKeyDown() override {
		std::cout << "按钮获取键盘焦点！" << std::endl;
		eventManager.publish("ButtonKeyDownEvent");
	}
};

// 订阅者类
class Subscriber {
public:
	void handleButtonClick() {
		std::cout << "收到按钮点击事件并进行处理" << std::endl;
		// 具体的处理逻辑
	}

	void handleButtonHover() {
		std::cout << "收到按钮悬停事件并进行处理" << std::endl;
		// 具体的处理逻辑
	}

	void handleButtonKeyDown() {
		std::cout << "收到按钮键盘按下事件并进行处理" << std::endl;
		// 具体的处理逻辑
	}
};

int main() {
	EventManager eventManager;
	Button button(eventManager);
	Subscriber subscriber;

	// 订阅按钮事件
	eventManager.subscribe("ButtonClickedEvent", [&]() { subscriber.handleButtonClick(); });
	eventManager.subscribe("ButtonHoveredEvent", [&]() { subscriber.handleButtonHover(); });
	eventManager.subscribe("ButtonKeyDownEvent", [&]() { subscriber.handleButtonKeyDown(); });

	// 模拟用户与按钮交互
	button.onClick();
	button.onHover();
	button.onKeyDown();

	return 0;
}