我想为一个 CG 项目实现一个 Mesh 类，但遇到了一些问题。 我想要做的是一个 Mesh 类，它向用户隐藏实现细节(比如加载到特定 API:OpenGL、DirectX、CUDA 等)。此外，由于 Mesh 类将用于研究项目，因此该 Mesh 类必须非常灵活。

class Channel {
  virtual loadToAPI() = 0;      
}

template <class T>
class TypedChannel : public Channel {

  std::vector<T> data;
};

template <class T>
class OpenGLChannel : public TypedChannel<T> {

  loadToAPI(); // implementation
};

class Mesh {

  template<class T>
  virtual TypedChannel<T>* createChannel() = 0; // error: no virtual template functions

  std::vector<Channel*> channels;
};

class OpenGLMesh {

  template<class T>
  TypedChannel<T>* createChannel()
  {
    TypedChannel<T>* newChannel = new OpenGLChannel<T>;
    channels.push_back(newChannel);
    return newChannel;
  };
};

为了灵 active ，每个网格实际上是 channel 的集合，例如一个位置 channel 、一个法线 channel 等，它们描述了网格的某些方面。 channel 是 std::vector 的包装器，具有一些附加功能。

为了隐藏实现细节，每个 API(OpenGLMesh、DirectXMesh、CUDAMesh 等)都有一个派生类来处理特定于 API 的代码。 channel (处理将 channel 数据加载到 API 的 OpenGLChannel 等)也是如此。 Mesh 充当 Channel 对象的工厂。

但问题来了:由于Channels是模板类，createChannel必须是模板方法，而模板方法不能是virtual。我需要的是用于创建模板化对象的工厂模式之类的东西。有没有人对如何完成类似的事情有建议？

谢谢

最佳答案

这是一个有趣的问题，但让我们先讨论编译器错误。

正如编译器所说，一个函数不能既是虚函数又是模板函数。要理解原因，只需考虑实现:大多数时候，具有虚函数的对象都有一个虚表，其中存储指向每个函数的指针。

然而对于模板来说，函数的数量与类型的组合一样多:那么虚拟表应该是什么样的呢？在编译时无法判断，您的类的内存布局包括虚拟表并且必须在编译时决定。

现在解决你的问题。

最简单的解决方案是为每种类型编写一个虚拟方法，当然这很快就会变得乏味，所以让我们假装你没有听说过。

如果 Mesh 不应该知道各种类型，那么您肯定不需要该函数是 virtual，因为给定一个实例谁会知道Mesh 的类型，调用函数的类型是什么？

Mesh* mesh = ...;
mesh.createChannel<int>(); // has it been defined for that `Mesh` ??

另一方面，我假设 OpenGLMesh 确实知道它需要哪种类型的 TypedChannel。如果是这样，我们可以使用一个非常简单的技巧。

struct ChannelFactory
{
  virtual ~ChannelFactory() {}
  virtual Channel* createChannel() = 0;
};

template <class T>
struct TypedChannelFactory: ChannelFactory
{
};

然后:

class Mesh
{
public:
  template <class T>
  Channel* addChannel()
  {
    factories_type::const_iterator it = mFactories.find(typeid(T).name());
    assert(it != mFactories.end() && "Ooops!!!" && typeid(T).name());

    Channel* channel = it->second->createChannel();
    mChannels.push_back(channel);
    return channel;
  } // addChannel

protected:
  template <class T>
  void registerChannelFactory(TypedChannelFactory<T>* factory)
  {
    mFactories.insert(std::make_pair(typeid(T).name(), factory));
  } // registerChannelFactory

private:
  typedef std::map < const char*, ChannelFactory* const > factories_type;
  factories_type mFactories;

  std::vector<Channel*> mChannels;
}; // class Mesh

它演示了一个非常强大的习惯用法，称为类型删除。你可能在知道这个名字之前就用过它:)

现在，您可以将 OpenGLMesh 定义为:

template <class T>
struct OpenGLChannelFactory: TypedChannelFactory<T>
{
  virtual Channel* createChannel() { return new OpenGLChannel<T>(); }
};

OpenGLMesh::OpenGLMesh()
{
  this->registerChannelFactory(new OpenGLChannelFactory<int>());
  this->registerChannelFactory(new OpenGLChannelFactory<float>());
}

你会像这样使用它:

OpenGLMesh openGLMesh;
Mesh& mesh = openGLMesh;

mesh.addChannel<int>();    // fine
mesh.addChannel<float>();  // fine

mesh.addChannel<char>();   // ERROR: fire the assert... (or throw, or do nothing...)

希望我明白你需要什么 :p

关于c++ - 创建模板化对象时替代工厂模式 - C++，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/2207159/