使用抽象工厂和模板元编程的可扩展架构

我目前正在写硕士论文，似乎我找不到一个令人满意的解决方案。这里的想法是设计一个应该从底层api(如DirectX11和OpenGL4)抽象的小库。在同一个应用程序中不需要两个或多个api共存，所以理论上我可以编写一堆预处理器指令来区分它们，但是这会破坏我的代码，当然，它根本无法扩展。

抽象工厂似乎很方便，但是我似乎找不到一种方法使它与模板一起工作。

让我们开始…

我有一个抽象类Factory，其目的是实例化应用程序工作所需的对象，如Resources和Context。前者用于在运行时加载资源，后者用于渲染3D场景。Resources和Context都是抽象的，因为它们的实现依赖于底层API。

class Factory{
   public:
      virtual Resources & GetResources() = 0;
      virtual Context & GetContext() = 0;
}

Resources类将加载所需的资源，并返回类型为Texture2D和Mesh的对象。同样，这些类是抽象的，因为它们依赖于特定的API。

假设我正在使用DirectX11和OpenGL4.5。对于每个api，我都派生了上面的类，分别是DX11Factory、DX11Resources、DX11Context、DX11Texture2D、DX11Mesh等等。它们所扩展的类非常明显。很好。

设计Resource类接口的简单方法如下:

class Resources{
   public:
      Texture2D LoadTexture(const wstring & path) = 0;
      Mesh LoadMesh(const wstring & path) = 0;
}

类DX11Resource将实现上述方法，一切都会正常工作…除非我想在未来支持像TextureCube这样的新资源类型(从软件工程师的角度来看，我肯定会的)。现在我不在乎)，我必须在库用户实际使用的接口中声明一个新方法TextureCube LoadTextureCube(...)，即Resources。这将意味着我必须在每个派生类中实现该方法(开闭原则FTW!)。

我解决这个问题的第一个想法是:

class Texture2D{...}
class Resources{
   public:
      template<typename TResource>
      virtual TResource Load(const wstring & path) = 0; // :(
}   
namespace dx11{
   class DX11Texture2D: public Texture2D{...}
   class DX11Texture2DLoader{...}
   template<typename TResource> struct resource_traits;
   template<> struct resource_traits<Texture2D>{
      using type = DX11Texture2D;
      using loader = DX11Texture2DLoader; //Functor type
   }
   class DX11Resources{
      public:
         template<typename TResource>
         virtual TResource Load(const wstring & path){
            return typename resource_traits<TResource>::loader()( path );
         }
   }
}

因此，如果我需要支持一种新的资源类型，我可以简单地在适当的名称空间内声明一个新的resource_traits(当然还有新的资源抽象和具体类型)，一切都会工作。不幸的是，虚拟模板方法不受支持(有一个很好的理由，想象一下写这样的东西会发生什么情况

Resources * r = GrabResources(); //It will return a DirectX9 object
r->Load<HullShader>(L"blah");  //DX9 doesn't support HullShaders, thus have no resource_traits<HullShader>

所以基本上编译器将不能执行一个适当的替换，它会指出一个错误，一个类的用户甚至没有意识到。)

我考虑过其他的解决方案，但没有一个能满足我的需要:

<标题> 1。CRTP h1> 可以这样写:

template <typename TDerived>
class Resources{
   public:
      template <typename TResource>
      TResource Load(const wstring & path){
         return typename TDerived::resource_traits<TResource>::loader()( path );
      }
}

我认为这将工作，然而Resources<TDerived>不能由Factory对象返回，仅仅因为TDerived是未知的(最终程序员不应该知道)。

<标题> 2。RTTI h1> 派生类中，我必须实现上面的纯虚拟方法，然后，使用if-then-else级联，我可以实例化我需要的资源，或者如果特定API不支持它，则返回nullptr。这肯定会工作，但它是丑陋的，当然它迫使我重写实现每当我想支持一个新的资源类型(但至少它将只是一个类)!

if( hash == typeid(Texture2D).hash_code()) // instantiate a DX11Texture2D
else if (...)...

<标题> 3。游客h1> 用访问者模式。这个方法实际上对我没有任何帮助，但我把它留在这里以防万一(每当我看到一个永不结束的if-then-else级联，就像上一点一样，我总是想到访问者:))。

template <typename TResource> resource_traits;
template<> resource_traits<Texture2D>{
   using visitable = Texture2DVisitable;
}
struct Texture2DVisitable{
   Texture2D operator()(const wstring & path, Loader & visitor){
      return visitor.Load(path, *this);
   }
}
template<typename TResource>
TResource Resources::Load(path){
   return typename resource_traits<TResource>::visitable()(path, *this);
}

使用这种方法，Resources现在必须为它可以加载的每个资源(如Texture2D Resources::Load(path, Texture2DVisitable &) = 0)声明一个纯虚拟方法。所以，再一次，如果有新的资源，我必须相应地更新整个层次结构……此时，我将使用开始时的平凡解。

<标题> 4。其他人呢?我错过什么了吗?我应该选择哪种方法?我觉得我总是把事情弄得太复杂了!

提前感谢并为我写得很差的墙-o-text感到抱歉!

ps:首先摆脱Resource类不是一个选项，因为它的真正目的是防止反复加载相同的资源。

// Resources.h:
class Resources {
  public:
    template <typename TResource>
    TResource Load(const wstring & path){
      return *static_cast<TResource *>(Load(path, std::type_index(typeid(TResource))));
    }
  protected:
    virtual void* Load(const wstring & path, std::type_index t_id) = 0;
}
// DX11Resources.h:
class DX11Resources : public Resources {
  protected:
    void* Load(const wstring & path, std::type_index t_id);
};
// DX11Resources.cpp:
template <typename TResource>
void* DX11Res_Load(DX11Resources& res, const wstring & path) { };
template <>
void* DX11Res_Load<Texture2D>(DX11Resources& res, const wstring & path) {
  // code to load Texture2D
};
// .. so on for other things..
void* DX11Resources::Load(const wstring & path, std::type_index t_id) {
  typedef void* (*p_load_func)(DX11Resources&, const wstring&);
  typedef std::unordered_map<std::type_index, p_load_func> MapType;
  #define DX11RES_SUPPORT_LOADER(TYPENAME) MapType::value_type(std::type_index(typeid(TYPENAME)), DX11Res_Load<TYPENAME>)
  static MapType func_map = {
    DX11RES_SUPPORT_LOADER(Texture2D),
    DX11RES_SUPPORT_LOADER(Texture3D),
    DX11RES_SUPPORT_LOADER(TextureCube),
    //...
  };
  #undef DX11RES_SUPPORT_LOADER
  auto it = func_map.find(t_id);
  if(it == func_map.end())
    return nullptr;  // or throw exception, whatever you prefer.
  return it->second(*this, path);
};