【CI130x 离在线】 C++一个类中调用另一个类的方法

有几种解决方案，根据你的具体需求选择：

方案1：传递CISerialPort对象引用（推荐）

在需要使用CheckConnection()的类中持有CISerialPort的引用：

cpp

// 在需要使用CheckConnection的类中
class MyOtherClass {
private:
    CISerialPort& serial_port_;  // 引用
    
public:
    // 通过构造函数传入
    MyOtherClass(CISerialPort& serial_port) : serial_port_(serial_port) {}
    
    void SomeMethod() {
        if (serial_port_.CheckConnection()) {
            // 串口连接正常
            std::cout << "串口连接正常" << std::endl;
        } else {
            // 串口连接异常
            std::cout << "串口连接异常" << std::endl;
        }
    }
};

// 使用示例
CISerialPort serial;
serial.Initialize("/dev/ttyUSB0", 115200);

MyOtherClass other_class(serial);  // 传入串口对象
other_class.SomeMethod();

方案2：传递CISerialPort指针

cpp

class MyOtherClass {
private:
    CISerialPort* serial_port_;  // 指针
    
public:
    MyOtherClass(CISerialPort* serial_port) : serial_port_(serial_port) {}
    
    void SomeMethod() {
        if (serial_port_ && serial_port_->CheckConnection()) {
            // 串口连接正常
        }
    }
};

// 使用示例
CISerialPort serial;
MyOtherClass other_class(&serial);
other_class.SomeMethod();

方案3：使用单例模式（如果合适）

如果整个系统只需要一个串口实例：

cpp

// 在CISerialPort.h中修改
class CISerialPort {
private:
    static CISerialPort* instance_;  // 单例实例
    
public:
    static CISerialPort* GetInstance() {
        if (!instance_) {
            instance_ = new CISerialPort();
        }
        return instance_;
    }
    
    // 原有方法保持不变
    bool CheckConnection();
    bool IsConnected() const;
};

// 在CISerialPort.cpp中
CISerialPort* CISerialPort::instance_ = nullptr;

// 在其他类中使用
class MyOtherClass {
public:
    void SomeMethod() {
        CISerialPort* serial = CISerialPort::GetInstance();
        if (serial->CheckConnection()) {
            // 使用串口
        }
    }
};

方案4：使用全局变量（简单但不推荐）

cpp

// 全局声明
extern CISerialPort g_serial_port;

// 在其他类中使用
class MyOtherClass {
public:
    void SomeMethod() {
        if (g_serial_port.CheckConnection()) {
            // 使用串口
        }
    }
};

完整示例（推荐方案1）

MyOtherClass.h

cpp

#include "ci_serial_port.h"

class MyOtherClass {
private:
    CISerialPort& serial_port_;
    
public:
    MyOtherClass(CISerialPort& serial_port);
    void CheckAndUseSerial();
    void ProcessData();
};

MyOtherClass.cpp

cpp

#include "MyOtherClass.h"

MyOtherClass::MyOtherClass(CISerialPort& serial_port) 
    : serial_port_(serial_port) {
}

void MyOtherClass::CheckAndUseSerial() {
    // 检查连接状态
    if (!serial_port_.CheckConnection()) {
        std::cerr << "串口连接异常，无法处理数据" << std::endl;
        return;
    }
    
    // 连接正常，继续处理
    ProcessData();
}

void MyOtherClass::ProcessData() {
    // 读取串口数据
    auto data = serial_port_.ReadFromSerial();
    if (!data.empty()) {
        // 处理数据...
    }
}

main.cpp

cpp

#include "ci_serial_port.h"
#include "MyOtherClass.h"

int main() {
    // 创建串口对象
    CISerialPort serial_port;
    
    // 初始化串口
    if (!serial_port.Initialize("/dev/ttyUSB0", 115200)) {
        return -1;
    }
    
    // 创建其他类对象并传入串口引用
    MyOtherClass processor(serial_port);
    
    // 使用
    while (true) {
        processor.CheckAndUseSerial();
        usleep(100000); // 100ms
    }
    
    return 0;
}

建议

• 推荐方案1（传递引用）：最安全，面向对象，易于测试

• 如果多个地方需要访问同一个串口，考虑方案3（单例）

• 避免方案4（全局变量），不利于代码维护和测试

选择哪种方案取决于你的具体架构设计。