c++多设备并发运行且互相处理 上位机软件结构
2025-09-14 21:34 tlnshuju 阅读(11) 评论(0) 收藏 举报c++
多个物理设备同步运行，如何解决彼此之间的操作问题
做法是通过多主体建模
流程
先把用到的类全部前置声明
声明 所有的类的函数，但是不要实现他
声明管理者类的类函数，不要实现
接着是 搭建不同的类的函数
使用的时候， 管理者负责统一申请所有的被管理者类，继而这些类要想操作其他类，通过 管理者类给他的指针即可。
需要的技术基础：
c++类的前置
类接口的声明
类接口的实现
多线程技巧，每个类都只有一个消息循环和一个 私有线程负责处理消息和 给其他类投递消息
需要关注的地方：
消息在多主体网络中的传递，分发，返回，校验和任务异常处理
简单代码如下：
// 合并版测试代码（C++17，修复类定义顺序问题）
#include <iostream>
#include <thread>
#include <atomic>
#include <mutex>
#include <memory>
#include <random>
#include <chrono>
#include <stdexcept>
// ---------------------- 前置声明 ----------------------
class A
;
class B
;
class C
;
struct Manager;
// ---------------------- 共享数据结构体 ----------------------
struct CombinedData {
int a_id;
// A 的标识
int b_value;
// B 的私有参数
int timestamp;
// 时间戳
};
// ---------------------- 类 B（提前定义，确保 Manager 能访问其成员） ----------------------
class B
{
private:
std::shared_ptr<Manager> mgr;
// 管理器指针（后续补充）
std::thread worker;
// 私有线程
std::atomic<
bool> running{
false
};
// 运行标志
int current_value;
// 私有参数
mutable std::mutex value_mutex;
// 保护参数的互斥锁
// 线程入口函数
void workerThread();
public:
explicit B(std::shared_ptr<Manager> mgr_ptr)
: mgr(mgr_ptr), current_value(0) {
}
~B() {
stop();
}
void start();
void stop();
// 线程安全获取参数（完整定义，Manager 可访问）
int getValue() const;
};
// ---------------------- 类 C（提前定义，确保 Manager 能访问其成员） ----------------------
class C
{
private:
std::shared_ptr<Manager> mgr;
// 管理器指针（后续补充）
public:
explicit C(std::shared_ptr<Manager> mgr_ptr) : mgr(mgr_ptr) {
}
// 接收数据并打印（完整定义，Manager 可访问）
void receiveData(const CombinedData& data);
};
// ---------------------- 管理器 Manager（B 和 C 已定义，可安全调用其成员） ----------------------
struct Manager {
std::shared_ptr<A> a;
// 持有 A 的智能指针（A 后续定义）
std::shared_ptr<B> b;
// 持有 B 的智能指针（B 已定义）
std::shared_ptr<C> c;
// 持有 C 的智能指针（C 已定义）
// 注册类实例（测试中可省略）
void registerA(std::shared_ptr<A> a_ptr) { a = a_ptr;
}
void registerB(std::shared_ptr<B> b_ptr) { b = b_ptr;
}
void registerC(std::shared_ptr<C> c_ptr) { c = c_ptr;
}
// 线程安全获取 B 的参数（B 已定义，可调用 getValue()）
int getBValue() const {
if (!b) throw std::runtime_error("Manager: B 未注册！");
return b->
getValue();
// 正确调用 B 的成员函数
}
// 线程安全发送数据给 C（C 已定义，可调用 receiveData()）
void sendToC(const CombinedData& data) {
if (!c) throw std::runtime_error("Manager: C 未注册！");
c->
receiveData(data);
// 正确调用 C 的成员函数
}
};
// ---------------------- 类 A（B 和 C 已定义，可安全使用） ----------------------
class A
{
private:
std::shared_ptr<Manager> mgr;
// 管理器指针（Manager 已定义）
std::thread worker;
// 私有线程
std::atomic<
bool> running{
false
};
// 运行标志
int a_id;
// A 的 ID
// 线程入口函数
void workerThread();
public:
explicit A(int id, std::shared_ptr<Manager> mgr_ptr)
: a_id(id), mgr(mgr_ptr) {
}
~A() {
stop();
}
void start();
void stop();
};
// ---------------------- 类 B 成员函数实现（B 已完整定义） ----------------------
void B::workerThread() {
std::random_device rd;
std::mt19937 gen(rd());
std::uniform_int_distribution<
>
dist(10, 100);
// 随机数范围 10~100
while (running) {
std::this_thread::sleep_for(std::chrono::seconds(1));
// 每 1 秒更新一次
// 更新参数（加锁保护）
{
std::lock_guard<std::mutex>
lock(value_mutex);
current_value = dist(gen);
}
std::cout <<
"B 更新参数: " << current_value <<
"\n";
}
}
void B::start() {
if (running) return;
running = true;
worker = std::thread(&B::workerThread, this);
std::cout <<
"B 启动\n";
}
void B::stop() {
if (!running) return;
running = false;
if (worker.joinable()) worker.join();
std::cout <<
"B 停止\n";
}
int B::getValue() const {
std::lock_guard<std::mutex>
lock(value_mutex);
return current_value;
}
// ---------------------- 类 C 成员函数实现（C 已完整定义） ----------------------
void C::receiveData(const CombinedData& data) {
std::cout <<
"C 接收数据 | A ID: " << data.a_id
<<
" | B 值: " << data.b_value
<<
" | 时间戳: " << data.timestamp <<
"\n";
}
// ---------------------- 类 A 成员函数实现（A 已完整定义） ----------------------
void A::workerThread() {
while (running) {
std::this_thread::sleep_for(std::chrono::seconds(2));
// 每 2 秒执行一次
try {
// 1. 通过管理器获取 B 的参数（B 已定义，可调用 getValue()）
int b_val = mgr->
getBValue();
// 2. 组合数据（C++17 聚合初始化）
CombinedData data{
};
data.a_id = a_id;
data.b_value = b_val;
data.timestamp = static_cast<
int>
(std::chrono::system_clock::now().time_since_epoch().count());
// 3. 通过管理器发送给 C（C 已定义，可调用 receiveData()）
mgr->
sendToC(data);
} catch (const std::exception& e) {
std::cerr <<
"A " << a_id <<
" 异常: " << e.what() <<
"\n";
}
}
}
void A::start() {
if (running) return;
running = true;
worker = std::thread(&A::workerThread, this);
std::cout <<
"A " << a_id <<
" 启动\n";
}
void A::stop() {
if (!running) return;
running = false;
if (worker.joinable()) worker.join();
std::cout <<
"A " << a_id <<
" 停止\n";
}
// ---------------------- 主函数（测试逻辑） ----------------------
int main() {
// 1. 创建管理器（智能指针管理生命周期）
auto mgr = std::make_shared<Manager>
();
// 2. 创建 A、B、C 实例（传递管理器指针）
auto a = std::make_shared<A>
(1, mgr);
auto b = std::make_shared<B>
(mgr);
auto c = std::make_shared<C>
(mgr);
// 3. 注册实例到管理器（可选，测试中直接通过构造函数传递已足够）
mgr->
registerA(a);
mgr->
registerB(b);
mgr->
registerC(c);
// 4. 启动 A 和 B 的线程
a->
start();
b->
start();
// 5. 主线程运行 10 秒
std::this_thread::sleep_for(std::chrono::seconds(10));
// 6. 停止所有线程
a->
stop();
b->
stop();
std::cout <<
"测试结束\n";
return 0;
}具体简单代码如下，不理解的可以联系我给你介绍一下
浙公网安备 33010602011771号