基于QT的C++中小项目软件开发架构源码

🕗 发布于 2024-09-24 08:39 qt c++ 架构

描述

基于QT信号槽机制实现类之间的交互调用通信，适用于使用不同枚举作为消息交互的类型场景，支持附带任意参数，代码使用方式参考前一篇文章

特性

仅需包含一个头文件Communicator.h，需要通信的业务类继承Communicator，界面类继承VCommunicator或MVCommunicator。
消息通过枚举类型定义，支持任意枚举消息，添加枚举无需改动代码。枚举名称区分消息类型，枚举值区分具体消息
使用便捷，只需注册消息和消息处理函数
提供发送消息时，附带any传递任意额外信息
支持多线程，同QT一致的信号槽触发方式，如需控制信号槽触发方式，需要额外补充代码

对比QT信号槽

适用于使用不同枚举作为消息类型场景，支持附带任意参数
使用同QT一样便捷，只需注册消息和消息回调函数。且如果使用QT的信号槽进行通信，不同的消息的类型则需要定义多个connect连接函数，如ELoginMsg、ERunMsg，多一种消息就要多一个connect

Communicator.h

#pragma once
#include <QMainWindow>
#include <functional>
#include <unordered_map>
#if __cplusplus >= 201703L
#include <any>
#else 
#include <typeinfo>
#include <memory>
namespace std {
class any
{
class AnyHelperBase
{
public:
virtual const std::type_info& type()const = 0;
virtual AnyHelperBase* clone()const = 0;
};

template<typename T>
class AnyHelper :public AnyHelperBase
{
public:
T data;
template<typename ...Args>
AnyHelper(Args&&... args) :data(std::forward<Args>(args)...) {}
AnyHelper(const AnyHelper& rhs) :data(rhs.data) {}
AnyHelper(const T& value) :data(value) {}
virtual const std::type_info& type() const
{
return typeid(T);
}
virtual AnyHelper* clone() const
{
return new AnyHelper(*this);
}
};
template<typename T>
friend T any_cast(const any& a);
private:
std::unique_ptr<AnyHelperBase> pdata{};
public:
any() :pdata(nullptr) {}
template<typename T>
any(T&& value) : pdata(new AnyHelper<std::decay_t<T>>(value)) {}
any(const any& rhs) {
if (rhs.pdata != nullptr) {
pdata.reset(rhs.pdata->clone());
}
}
any(any& rhs) {
if (rhs.pdata != nullptr) {
pdata.reset(rhs.pdata->clone());
}
}
any(any&& rhs) :pdata(rhs.pdata.release()) {}

const std::type_info& type() const
{
return pdata->type();
}
bool has_value() const {
return pdata != nullptr;
}
void reset() {
pdata.reset();
}
template<typename T>
any& operator=(T value) {
pdata.reset(new AnyHelper<std::decay_t<T>>(value));
return *this;
}
any& operator=(any rhs)
{
pdata.reset(rhs.pdata->clone());
return *this;
}
};

template<typename T>
T any_cast(const any& a)
{
auto p = dynamic_cast<any::AnyHelper<std::decay_t<T>>*>(a.pdata.get());
if (p == nullptr)
throw std::runtime_error("Bad any cast!");
return p->data;
}
}
#endif

class MsgHandler {
public:
using MsgID = size_t;
using MsgHandleFunc = std::function<void(std::any)>;
using MsgHandleFuncNoPara = std::function<void()>;
template<typename T, typename = std::enable_if_t<std::is_enum<T>::value, void>>
void HandleMsg(T msg, std::any info = std::any{}) {
m_msgHandlers[HashID(msg)](info);
}
protected:
template<typename T, typename = std::enable_if_t<std::is_enum<T>::value, void>>
MsgID HashID(T msg) {
return std::hash<std::string>()(typeid(T).name()) ^ std::hash<size_t>()(static_cast<size_t>(msg));
}
template<typename T, typename = std::enable_if_t<std::is_enum<T>::value, void>>
void RegisterMsgHandler(T msg, MsgHandleFuncNoPara func) {
m_msgHandlers.insert({ HashID(msg),[=](std::any) {func(); } });
}
template<typename T, typename = std::enable_if_t<std::is_enum<T>::value, void>>
void RegisterMsgHandler(T msg, MsgHandleFunc func) {
m_msgHandlers.insert({ HashID(msg), func });
}
template<typename T, typename = std::enable_if_t<std::is_enum<T>::value, void>>
void RemoveMsgHandler(T msg) {
if (auto findit = m_msgHandlers.find(msg); findit != m_msgHandlers.end()) {
m_msgHandlers.erase(findit);
}
}
protected:
std::unordered_map<MsgID, MsgHandleFunc> m_msgHandlers;
};

class Communicator : public QObject, public MsgHandler {
Q_OBJECT
public:
Communicator(QObject* parent = nullptr) : QObject(parent) {
qRegisterMetaType<MsgID>("MsgID");
qRegisterMetaType<std::any>("std::any");
}
signals:
void SendMsg(MsgID, std::any);
public:
void HandleHashMsg(MsgID msgID, std::any info = std::any{}) {
if (bool findHandler = m_msgHandlers.find(msgID) != m_msgHandlers.end()) {
m_msgHandlers[msgID](info);
}
}
public:
template<typename Communicator1>
void Connect(Communicator1* receiver) {
connect(this, &Communicator::SendMsg, receiver, &Communicator1::HandleHashMsg);
}
template<typename Communicator1>
void Disconnect(Communicator1* receiver) {
disconnect(this, &Communicator::SendMsg, receiver, &Communicator1::HandleHashMsg);
}
template<typename T, typename = std::enable_if_t<std::is_enum<T>::value, void>>
void Emit(T msg, std::any info = nullptr) {
emit SendMsg(HashID(msg), info);
}
};

class ViewCommunicator : public QWidget, public MsgHandler {
Q_OBJECT
public:
ViewCommunicator(QWidget* parent = nullptr) : QWidget(parent) {
qRegisterMetaType<MsgID>("MsgID");
qRegisterMetaType<std::any>("std::any");
}
signals:
void SendMsg(MsgID, std::any);
public:
void HandleHashMsg(MsgID msgID, std::any info = std::any{}) {
if (bool findHandler = m_msgHandlers.find(msgID) != m_msgHandlers.end()) {
m_msgHandlers[msgID](info);
}
}
public:
template<typename Communicator1>
void Connect(Communicator1* receiver) {
connect(this, &ViewCommunicator::SendMsg, receiver, &Communicator1::HandleHashMsg);
}
template<typename Communicator1>
void Disconnect(Communicator1* receiver) {
disconnect(this, &ViewCommunicator::SendMsg, receiver, &Communicator1::HandleHashMsg);
}
protected:
template<typename T, typename = std::enable_if_t<std::is_enum<T>::value, void>>
void Emit(T msg, std::any info = nullptr) {
emit SendMsg(HashID(msg), info);
}
};

class MViewCommunicator : public QMainWindow, public MsgHandler {
Q_OBJECT
public:
MViewCommunicator(QWidget* parent = nullptr) :QMainWindow(parent) {
qRegisterMetaType<MsgID>("MsgID");
qRegisterMetaType<std::any>("std::any");
}
signals:
void SendMsg(MsgID, std::any);
public:
void HandleHashMsg(MsgID msgID, std::any info = std::any{}) {
if (bool findHandler = m_msgHandlers.find(msgID) != m_msgHandlers.end()) {
m_msgHandlers[msgID](info);
}
}
public:
template<typename Communicator1>
void Connect(Communicator1* receiver) {
connect(this, &MViewCommunicator::SendMsg, receiver, &Communicator1::HandleHashMsg);
}
template<typename Communicator1>
void Disconnect(Communicator1* receiver) {
disconnect(this, &MViewCommunicator::SendMsg, receiver, &Communicator1::HandleHashMsg);
}
protected:
template<typename T, typename = std::enable_if_t<std::is_enum<T>::value, void>>
void Emit(T msg, std::any info = std::any{}) {
emit SendMsg(HashID(msg), info);
}
};

namespace InterConnection {
template<typename Communicator1, typename Communicator2>
void Connect(Communicator1* c1, Communicator2* c2)
{
c1->Connect(c2);
c2->Connect(c1);
}

template<typename Communicator1, typename Communicator2>
void Disconnect(Communicator1* c1, Communicator2* c2)
{
c1->Disconnect(c2);
c2->Disconnect(c1);
}
}

补充

由于现在大多软件都是基于QT进行开发，QT又有自己的事件循环机制，所以只能进行拓展通信方式，也可以自行实现事件循环，但是跟QT结合起来用就不太适宜了。

原文地址：https://blog.csdn.net/weixin_42210846/article/details/142463780

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！

上一篇：Java框架学习（Maven）（01）
下一篇：特定transfomer架构的模型的压缩量化处理

Nginx反向代理简介，作用及配置；Nginx负载均衡简介，作用及配置；
Nginx反向代理简介，作用及配置；Nginx负载均衡简介，作用及配置；
阅读更多2024-09-25
如何设置网络黑名单禁止某些用户访问
设置网络黑名单以禁止某些用户访问你的网络资源通常涉及使用防火墙、路由器设置或服务器配置。以下是一些常见的方法：大多数防火墙（无论是硬件防火墙还是软件防火墙）都允许你创建黑名单来阻止特定IP地址或MAC
阅读更多2024-09-25
C++的哲学思想
C++的设计哲学：1. C++底层不应该基于任何其他语言 2.只为使用的东西付费 3.以低成本提供高级抽象
阅读更多2024-09-25
在 Visual Studio （VS2015）中搜索时使用正则表达式
在Visual Studio 2015（VS2015）中，使用搜索（通常是查找和替换功能）时，可以启用正则表达式模式来执行更复杂的文本匹配和替换操作。
阅读更多2024-09-25
JVM 的性能指标监测
JVM性能指标监测。
阅读更多2024-09-25
网站深色浅色切换案例-单页面，非全局。
【代码】网站深色浅色切换案例-单页面，非全局。
阅读更多2024-09-25
Leecode_SQL50_1280. Students and Examinations
注意一定要选择 a.subject_name！因为只有这个表是全的。若选择错了，有人的 subject_name 会是 null.用 CROSS JOIN 获取所有学生和科目的组合，不用有相同的列来
阅读更多2024-09-25
企微私域助手：重塑企业营销新生态的智能引擎
它不仅帮助企业高效管理私域流量，提升营销效率与转化率，更重要的是，通过深度链接用户，构建了长期稳定的用户关系，为企业的可持续发展奠定了坚实基础。3、内容营销与自动化营销：支持内容库管理，企业可预设营销
阅读更多2024-09-25
信息技术的快速发展与未来展望
近年来，信息技术（IT）的迅猛发展给全球经济、社会和个人生活带来了深刻的变革。无论是大数据、云计算，还是人工智能、物联网等技术，IT技术的进步正不断推动着各行各业的数字化转型。本文将探讨当前信息技术的
阅读更多2024-09-25
【C++进阶】2024年了set、map还搞不懂底层细节？
关联式容器也是用来存储数据的，与序列式容器不同的是，关联式容器里面存的是结构的键值对，在数据检索时比序列式容器效率更高。set：存储唯一键的集合multiset：存储可以有重复键的集合map：存储唯一
阅读更多2024-09-25

基于QT的C++中小项目软件开发架构源码

描述

特性

对比QT信号槽

补充

相关文章