如何模拟方法模板的虚拟性

Question

我有一个类层次结构,我想引入一个方法模板,就像它是虚拟的一样.例如一个简单的层次结构:

class A {
  virtual ~A() {}

  template<typename T>
  void method(T &t) {}
};

class B : public A {
  template<typename T>
  void method(T &t) {}
};

然后我创建对象B:

A *a = new B();

我知道我可以获取存储在类型a的typeid(a).B::method当我知道类型时,如何动态调用正确的？我可能有这样的情况:

if(typeid(*a)==typeid(B))
    static_cast<B*>(a)->method(params);

但我想避免有这样的条件.我正在考虑创建一个std::mapwith typeid作为一个键,但我会把它作为一个值？

Answer 1

您可以使用"奇怪的重复模板模式" http://en.wikipedia.org/wiki/Curiously_recurring_template_pattern

使用此模式,基类将派生类类型作为模板参数,这意味着基类可以将自身强制转换为派生类型,以便在派生类中调用函数.它是虚拟函数的一种编译时实现,具有无需执行虚函数调用的额外好处.

template<typename DERIVED_TYPE>
class A {
public:
    virtual ~A() {}

    template<typename T>
    void method(T &t) { static_cast<DERIVED_TYPE &>(*this).methodImpl<T>(t); }
};

class B : public A<B>
{
friend class A<B>;

public:
    virtual ~B() {}

private:
    template<typename T>
    void methodImpl(T &t) {}
};

它可以像这样使用......

int one = 1;
A<B> *a = new B();
a->method(one);

Answer 2

您可能知道，您不能拥有虚函数的模板，因为整个虚函数都是类类型的一部分，并且必须提前知道。这排除了任何简单的“任意覆盖”。

如果可以的话，您可以将模板参数作为类的一部分：

template <typename T> class A
{
protected:
  virtual void method(T &);
};

template <typename T> class B : public A<T>
{
  virtual void method(T &); // overrides
};

更复杂的方法可能会使用一些调度程序对象：

struct BaseDispatcher
{
  virtual ~BaseDispatcher() { }
  template <typename T> void call(T & t) { dynamic_cast<void*>(this)->method(t); }
};
struct ConcreteDispatcher : BaseDispatcher
{
  template <typename T> void method(T &);
};

class A
{
public:
  explicit A(BaseDispatcher * p = 0) : p_disp(p == 0 ? new BaseDispatcher : p) { }
  virtual ~A() { delete p_disp; };
private:
  BaseDispatcher * p_disp;
  template <typename T> void method(T & t) { p_disp->call(t); }
};

class B : public A
{
public:
  B() : A(new ConcreteDispatcher) { }
  // ...
};