如何用C++封装带void*参数的第三方C库并实现类型安全与可Mock？

核心思路 #

通过类型安全的模板函数对外提供上层接口，内部用类型擦除适配基类的虚函数（用于Mock），在封装层统一处理返回值检查和异常抛出，让上层完全摆脱void*和返回码的繁琐逻辑。

具体实现 #

1. 定义抽象基类（用于依赖注入与Mock） #

基类仅暴露供内部调用的虚函数，上层不直接操作：

// interface.h
class HardwareInterface {
public:
    virtual ~HardwareInterface() = default;

protected:
    // 底层虚接口，对接C库API
    virtual int do_iocall(int cmd, void* args) = 0;
    virtual int do_iorw(int cmd, void* buff, size_t buff_size) = 0;
};

2. 实现具体封装类 #

提供类型安全的模板函数作为上层入口，内部调用虚函数对接C库，并处理异常：

// interface_impl.h
#include <stdexcept>
#include <string>
#include <type_traits>

class HardwareWrapper : public HardwareInterface {
public:
    // 类型安全的iocall封装：支持任意可寻址类型
    template<typename T>
    void iocall(int cmd, T& args) {
        int ret = do_iocall(cmd, &args);
        if (ret != 0) {
            throw std::runtime_error("iocall failed, code: " + std::to_string(ret));
        }
    }

    // 单对象iorw封装：要求类型可平凡复制（避免内存不安全）
    template<typename T>
    void iorw(int cmd, T& buff) {
        static_assert(std::is_trivially_copyable_v<T>, "Buffer type must be trivially copyable");
        int ret = do_iorw(cmd, &buff, sizeof(T));
        if (ret != 0) {
            throw std::runtime_error("iorw failed, code: " + std::to_string(ret));
        }
    }

    // 数组版iorw封装
    template<typename T, size_t N>
    void iorw(int cmd, T (&buff)[N]) {
        static_assert(std::is_trivially_copyable_v<T>, "Array element must be trivially copyable");
        int ret = do_iorw(cmd, buff, sizeof(buff));
        if (ret != 0) {
            throw std::runtime_error("iorw array failed, code: " + std::to_string(ret));
        }
    }

protected:
    int do_iocall(int cmd, void* args) override {
        return ::iocall(cmd, args); // 调用第三方C库函数
    }

    int do_iorw(int cmd, void* buff, size_t buff_size) override {
        return ::iorw(cmd, buff, buff_size); // 调用第三方C库函数
    }
};

3. GTest Mock实现 #

基于基类的虚函数做Mock，同时提供类型安全的辅助验证方法：

// mock_hardware.h
#include <gmock/gmock.h>
#include "interface.h"

class MockHardware : public HardwareInterface {
public:
    // 暴露Mock方法给测试用例
    MOCK_METHOD(int, do_iocall, (int cmd, void* args), (override));
    MOCK_METHOD(int, do_iorw, (int cmd, void* buff, size_t buff_size), (override));

    // 类型安全的预期调用辅助方法
    template<typename T>
    void ExpectIocall(int cmd, const T& expected_args, int return_code = 0) {
        EXPECT_CALL(*this, do_iocall(cmd, testing::_))
            .WillOnce(testing::Invoke([&](int, void* args) {
                *static_cast<T*>(args) = expected_args;
                return return_code;
            }));
    }
};

4. 上层服务类使用示例 #

依赖抽象基类，调用类型安全的接口，无需处理void*和返回码：

class DeviceService {
public:
    explicit DeviceService(HardwareInterface& hw) : hw_(hw) {}

    void configureSensor(int cmd, SensorConfig& config) {
        hw_.iocall(cmd, config); // 自动处理异常，类型安全
    }

    void readSensorData(int cmd, SensorData& data) {
        hw_.iorw(cmd, data); // 类型安全，编译器自动检查类型
    }

private:
    HardwareInterface& hw_;
};

方案优势 #

• 类型安全：上层调用必须传入明确类型，编译器自动检查，避免void*的不安全转换
• Mock友好：基类虚函数可直接被GTest Mock，测试无需修改上层业务代码
• 低维护成本：新增参数类型无需修改封装类，模板自动适配所有可寻址类型
• 异常统一处理：封装层集中处理返回值，抛出异常，上层无需手动检查返回码

内容的提问来源于stack exchange，提问作者WukasL