当前位置：首页 > news >正文

c++多设备并发运行且互相操作上位机软件结构

news 2025/9/13 16:53:12

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~100while (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;
}