Better way of using an opaque pointer for Pimpl

Question

I'm writing a C++ wrapper library around a number of different hardware libraries for embedded systems (firmware level), using various libraries from different vendors (C or C++). The API exposed by the header files should be vendor agnostic... all Vendor header libraries are not included in any of my header files.

A common pattern I have is making the vendor member data opaque, by only using a pointer to some "unknown" vendor struct/class/typedef/pod type.

// myclass.h
class MyClass 
{
 ...
private:
   VendorThing* vendorData;
};

and implementation (note: each implementation is vendor specific; all have the same *.h file)

// myclass_for_vendor_X.cpp
#include "vendor.h"
... {
   vendorData->doSomething();
or
   VendorAPICall(vendorData,...);
or whatever

The problem I have is that VendorThing can be lots of different things. It could be a class, struct, type or pod. I don't know, and I don't want to care in the header file. But if you pick the wrong one, then it doesn't compile if the vendor header file is included as well as my header file. For example, if this the actual declaration of VendorThing in "vendor.h":

typedef struct { int a; int b; } VendorThing;

Then you can't just forward-declare VendorThing as class VendorThing;. I don't care about what the type of VendorThing is at all, all I want is the public interface to think of it as void * (i.e allocate space for a pointer and that is it), and the implementation think of it using the correct pointer type.

Two solutions I have come across are the "d-pointer" method found in Qt, where you add a level of indirection by replacing VendorThing a new struct VendorThingWrapper

// myclass.h
struct VendorThingWrapper;
class MyClass 
{
 ...
private:
   VendorThingWrapper* vendorDataWrapper;
};

and in your cpp file

// myclass.cpp
#include "vendor.h"
struct VendorThingWrapper {
   VendorThing* vendorData;
};

... {
   vendorDataWrapper->vendorData->doSomething();
}

but this adds a second pointer dereference, which is not a huge deal, but as this is targeting embedded systems, I don't want to add that overhead just because the language can't do what I want.

The other thing is just declare it void

// myclass.h
class MyClass 
{
 ...
private:
   void* vendorDataUntyped;
};

and in the implememtation

//myclass.cpp
#include "vendor.h"
#define vendorData ((VendorThing*)vendorDataUntyped)

 ... {
   vendorData->doSomething();
}

but #define's always leave a bad taste in my mouth. There must be something better.

Answer 1

If you are willing to go the route of the VendorThingWrapper, then you simply allow the wrapper to contain the data itself, rather than a pointer to it. This gives you the abstraction layer and avoids the extra dereference.

// myclass.cpp
#include "vendor.h"
struct VendorThingWrapper {
   VendorThing vendorData;
};

... {
   vendorDataWrapper->vendorData.doSomething();
}

Answer 2

You can avoid the additional pointer dereference by using:

#include "vendor.h"

struct VendorThingWrapper : public VendorThing {};

Of course, at that point, it makes more sense to use the name MyClassData instead of VendorThingWrapper.

MyClass.h:

struct MyClassData;

class MyClass
{
   public:

      MyClass();
      ~MyClass();

   private:
      MyClassData* myClassData;
};

MyClass.cpp:

struct MyClassData : public VendorThing {};

MyClass::MyClass() : myClassData(new MyClassData())
{
}

MyClass::~MyClass()
{
   delete myClassData;
}

Update

I was able to compile and build the following program. The unnamed struct is not a problem.

struct MyClassData;

class MyClass
{
   public:

      MyClass();
      ~MyClass();

   private:
      MyClassData* myClassData;
};


typedef struct { int a; int b; } VendorThing;

struct MyClassData : public VendorThing
{
};

MyClass::MyClass() : myClassData(new MyClassData())
{
   myClassData->a = 10;
   myClassData->b = 20;
}

MyClass::~MyClass()
{
   delete myClassData;
}

int main() {}