Эффективный и элегантный интерфейс абстракции

Я пытаюсь создать общий интерфейс для двух сторонних библиотек, которые имеют схожую функциональность, чтобы я мог кодировать против абстрактного интерфейса и выбирать во время компиляции, какую реализацию использовать.

Мне нужен этот абстрактный интерфейс, чтобы не добавлять никаких накладных расходов, то есть о полиморфизме не может быть и речи. В любом случае это не нужно, так как используется только одна фактическая реализация. Итак, моя первоначальная попытка выглядела так:

AbstractInterface.h:

// Forward declarations of abstract types.
class TypeA;
class TypeB;
class TypeC;

TypeA *foo(TypeA *a, TypeB *b);
TypeB *bar(std::vector<TypeC*> &c);
TypeC *baz(TypeC *c, TypeA *c);

ImplementationOne.cpp:

class ActualTypeA {...};
using TypeA = ActualTypeA;   // Error!
...

К сожалению, это приводит к ошибке компиляции, говоря о том, что TypeA переопределяется с использованием различных типов, хотя предварительное объявление ничего не сообщало ему, кроме того, что это класс. Итак, следующее, что я попробовал, было так:

class TypeA : public ActualTypeA {};   // No more error
...
TypeA *foo(TypeA *a, TypeB *b)
{
return actualFoo(a, b);   // Error
}

Здесь actualFoo () возвращает ActualTypeA *, который не может быть автоматически преобразован в TypeA *. Поэтому я должен переписать его в нечто вроде:

inline TypeA *A(ActualTypeA *a)
{
return reinterpret_cast<TypeA*>(a);
}

TypeA *foo(TypeA *a, TypeB *b)
{
return A(actualFoo(a, b));
}

Причина, по которой я использую вспомогательную функцию A (), заключается в том, что я случайно не приводил что-то кроме ActualTypeA * в TypeA *. Во всяком случае, я не в восторге от этого решения, потому что мой фактический интерфейс состоит из десятков тысяч строк кода на реализацию. И все A (), B (), C () и т. Д. Затрудняют чтение.

Кроме того, реализация bar () потребует некоторого дополнительного вуду:

inline std::vector<ActualTypeC*> &C(std::vector<TypeC*> &t)
{
return reinterpret_cast<std::vector<ActualTypeC*>&>(t);
}

TypeB *bar(std::vector<TypeC*> &c)
{
B(actualBar(C(c));
}

Еще один способ решить эту проблему — избежать каких-либо изменений на стороне реализации:

AbstractInterface.h:

class ActualTypeA;
class ActualTypeB;
class ActualTypeC;

namespace ImplemetationOne
{
using TypeA = ActualTypeA;
using TypeB = ActualTypeB;
using TypeC = ActualTypeC;
}

class OtherActualTypeA;
class OtherActualTypeB;
class OtherActualTypeC;

namespace ImplemetationTwo
{
using TypeA = OtherActualTypeA;
using TypeB = OtherActualTypeB;
using TypeC = OtherActualTypeC;
}

// Pre-define IMPLEMENTATION as ImplementationOne or ImplementationTwo
using TypeA = IMPLEMENTATION::TypeA;
using TypeB = IMPLEMENTATION::TypeB;
using TypeC = IMPLEMENTATION::TypeC;

TypeA *foo(TypeA *a, TypeB *b);
TypeB *bar(std::vector<TypeC*> &c);
TypeC *baz(TypeC *c, TypeA *c);

Это приводит к тому, что кто-то может случайно использовать специфичные для реализации типы вместо абстрактных. Кроме того, он требует определения IMPLEMENTATION для каждого модуля компиляции, который включает этот заголовок, и требует, чтобы они были согласованными. Я бы предпочел просто скомпилировать либоОтверждениеOne.cpp, либо ВнедрениеTwo.cpp, и все. Другим недостатком является то, что для дополнительных реализаций потребуется изменение заголовка, даже если мы не заинтересованы в типах, специфичных для реализации.

Это кажется очень распространенной проблемой, поэтому мне интересно, не хватает ли мне более элегантного и все же эффективного решения?