时间戳

首页 > 解决方案 > 我有一个具有不同前缀的相关函数的 C 库。派生的 C++ 类如何在不重复代码的情况下调用它们？

c++ - 我有一个具有不同前缀的相关函数的 C 库。派生的 C++ 类如何在不重复代码的情况下调用它们？

问题描述

我正在使用与具有不同型号的硬件通信的驱动程序库。该硬件附带的 API 具有针对不同主要版本的不同库，即使许多交互是相同的。例如，如果我正在与 4000 系列设备通话，我会调用

handle_t handle;
dv4000_OpenDevice(&handle);
dv4000_DoSomething(handle);
dv4000_Close(handle);

对于 5000 系列设备

handle_t handle;
dv5000_OpenDevice(&handle);
dv5000_DoSomething(handle);
dv5000_Close(handle);

所以现在我想创建一个Device基类Device_Series4k和Device_Series5k派生类。如何在不复制大部分实现并换出函数调用的情况下实现这一点？请注意，不同系列的 API 并不 完全相同，因此在编译时生成具有名称替换的源文件的 make 规则将不起作用（尽管仅使用公共部分这样做可能是可行的）。

带有模板或宏的通用 C++ 解决方案将是理想的，但适用于 Linux/gcc 的 Makefile/shell 技巧也可以。

编辑在非常有限的上下文中工作的一个示例可能是：

class Device{
public: 
  typedef uint16_t handle_t;
  typedef int (*Opener)(handle_t*);
  typedef int (*Closer)(handle_t);

  Device(Opener open, Closer close) : _handle(0), _close(close)
  { open(&_handle); }

  ~Device(){ _close(_handle); } 

private:
  handle_t _handle;
  Closer _close;
};


class Device_Series4k : public Device { 
public:
  Device_Series4k : Device(dv4000_OpenDevice, dv4000_ClosDevice) {}
};

我可以对模板和额外的抽象层做同样的事情。如果我想在调用 open 之后进行错误检查或一堆常见的初始化/分配类型的事情，这仍然是一个净收益。但是如果我需要提供 20 个不同的 DoSomething 签名，它很快就会变得难以忍受。

标签： c++oopwrapper

解决方案

首先，您几乎肯定需要一个用于 RAII 的 DeviceHandle 类：

typedef void (*CloseDeviceFn)(handle_t);
class DeviceHandle {
    handle_t val;
    CloseDeviceFn close;
public:
    explicit DeviceHandle(handle_t v, CloseDeviceFn closeFn) noexcept : val(v), close(closeFn) {}
    DeviceHandle(DeviceHandle&& rhs) noexcept : val(rhs.release()) {}
    DeviceHandle& operator=(DeviceHandle&& rhs) noexcept {reset(rhs.release()); return *this;}
    ~DeviceHandle() noexcept {reset(nullptr);}

    handle_t get() noexcept {return val;}
    void reset(handle_t v) noexcept {if (val != nullptr) close(val); val = v;}
    handle_t release() noexcept {handle_t t = val; val = nullptr; return t;}
};

对于不改变的 API，您所要求的只是微不足道的：

class Device {
public:
    virtual ~Device() {}; //classes with any virtual methods should have a virtual destructor
    virtual void DoSomething();
};

class Device_Series4k: public Device {
    DeviceHandle handle;
public:
    explicit Device_Series4k(handle_t handle_)
    : handle_(handle, &dv4000_Close) {
        dv4000_OpenDevice(handle.get());
    }
    void DoSomething() {dv4000_DoSomething(handle.get());}
};

对于更改的 API，您可能必须具有版本化的基类：

class DeviceApis {
public:
    virtual ~Device() {};
    virtual int version() = 0;
    virtual void DoSomething() = 0;
};
class Device4000Apis: public Device {
public:
    virtual void DoNewerConcept();
};

然后Device_Series5k会 extend Device4000Apis，你必须像这样胡说八道：

DeviceApis myDevice = ...
Device4000Apis deviceAtLeast4000 = dynamic_cast<Device4000Apis>(myDevice);
if (deviceAtLeast4000 != nullptr) {
    deviceAtLeast4000.doNewerConcept();
} else {
    log.d("device doesn't support concept");
}

如果你真的想避免复制粘贴，你可以用模板伪造它：

template<OpenDeviceFn openDeviceFn,
         CloseDeviceFn closeDeviceFn,
         DoSomethingFn doSomethingFn>
class DeviceImpl: public Device {
    DeviceHandle handle;
public:
    explicit DeviceImpl(handle_t handle_)
    : handle(handle_, closeDeviceFn) {
        openDeviceFn(handle.get());
    }
    void DoSomething() {doSomethingFn(handle.get());}
};
typedef DeviceImpl<dv4000_OpenDevice, dv4000_Close, dv4000_DoSomething> Device_Series4k;

如此处所示：http: //coliru.stacked-crooked.com/a/f6974f463644da50

或者另一种选择是创建一个DeviceType具有指向各种方法的成员的类，并且每个成员Device都有一个指向 的指针DeviceType，这将允许您在不实际使用模板的情况下模拟模板选项，从而使实现远离标题，但也会干扰内联。

推荐阅读