Multiplatform class design C++

Question

I have had an idea for a non standard way to handle multiplatform interfaces in C++ and would like to know if that is generally a bad idea and why.

Currently I can only think of one disadvantage: It is very(?) uncommon do to something like that and maybe its not obvious how it works on first sight:

I have a class that will be used on different platforms, for example CMat4x4f32 (4x4 matrix class using 32 bit floats). My platform independent interface looks like this:

class CMat4x4f32
{
public:
    //Some methods

    #include "Mat4x4f32.platform.inl"
};

Mat4x4f32.platform.inl looks like this:

public:
    // Fills the matrix from a DirectX11 SSE matrix
    void FromXMMatrix(const XMMatrix& _Matrix);

It just adds a platform depending interface to the matrix class.

The .cpp and the Mat4x4f32.platform.inl are located inside subfolders like "win32" or "posix" so in win32 I implement the FromXMMatrix function. My buildsystem adds these subfolders to the include path depending on the platform I build for.

I could even go a step beyond and implement a .platform.cpp that is located inside win32 and contains only the functions I add to the interface for that platform.

I personally think this is a good idea because it makes writing and using interfaces very easy and clean. Especially in my Renderer library that heavily uses the Matrix class from my base library I can now use platform depending functions (FromXMMatrix) in the DirectX part as if I dont have any other platforms to worry about.

In the base library itself I can still write platform independent code using the common matrix interface.

I also have other classes where this is useful: For example an Error class that collects errors and automatically translates them into readable messages and provide some debugging options. For win32 I can create error instances from bad DirectX and Win32 HResults and on Linux I can create them from returned errno's. In the base library I have a class that manages these errors using the common error interface.

It heavily reduces code required and prevents having ugly platform depending util classes.

So is this bad or good design and what are the alternatives?

Answer 1

It sounds like you're talking about using the bridge pattern: http://c2.com/cgi/wiki?BridgePattern

In my personal experience I've developed a lot of platform independent interfaces, with specific implementations using this pattern and it has worked very well, I've often used it with the Pimpl idiom: http://c2.com/cgi/wiki?PimplIdiom

As in alternatives I've found that this site in general is very good for explaining pros & cons of various patterns and paradigms: http://c2.com/cgi/wiki