使用模板派生类的虚拟模板函数访问者解决方法

Question

问题是template <typename T> virtual void foo() 是非法的，我正在尝试使用访问者模式来解决这个问题（这通常是已知的）。但是 Base 的派生类是模板类，现在我在访问者类中遇到了虚拟模板问题。如何解决这个问题？

struct Base {
//  template <typename T> virtual void foo() = 0;  // illegal
    virtual void foo (class Visitor& visitor) = 0;  // The attempted solution
};

template <typename D>
struct Derived : Base {
    virtual void foo (Visitor&) override;
};

struct Visitor {
    //template <typename D> // same problem again!
    virtual void visit (Derived<D>*) const = 0;
};

template <typename T, typename D>
struct FooVisitor : Visitor {
    virtual void visit (Derived<D>*) const override {/*Do whatever with T*/}
};

template <typename D>
void Derived<D>::foo (Visitor& visitor) {visitor.visit(this);}

对于所有解决方案，我们假设 D 应该有大约一百个值，并且不断引入新的 D 类。每个人都会以同样的方式使用 D。为简单起见，我们假设每个访问函数都使用 D 和

func<D>();

在哪里

template <typename D> void Base::func();

是 Base 中的一些辅助函数。

Answer 1

这是一个可行的解决方案。请注意，这里的假设是您只使用正确的类型进行调用：

struct Base {
    virtual void foo(struct Visitor& visitor) = 0;
};

template <typename D>
struct Derived : Base {
    virtual void foo (Visitor&v) override;
};

struct Visitor {
    virtual ~Visitor() {} // Make this class polymorphic.
};

template <typename D>
struct Visitor_tmpl : public Visitor {
    virtual void visit (Derived<D>*) const {/*Do whatever with T*/}
};

template <typename T, typename D>
struct FooVisitor : Visitor_tmpl<D> {
    virtual void visit (Derived<D>*) const override {/*Do whatever with T*/}
};

template <typename D>
void Derived<D>::foo(Visitor&v) {
    // In this function, D has been bound now to a specific type, so we downcast.
    // It will throw an exception if not the right type.
    dynamic_cast<Visitor_tmpl<D> &>(v).visit(this);
}

int main() {
    Derived<int> d;
    FooVisitor<double, int> v;
    d.foo(v);
}

Answer 2

Jarod42 提到了一种可能的解决方案，即指定所有可能出现的类型。但是，通常您希望提供一个采用 Base* 的标准实现，并且仅在需要时重载它。

struct Type1 {};
//...
struct TypeN {};

struct Visitor
{
    virtual ~Visitor() {}

    virtual void visit (Base*) const = 0;
    virtual void visit (Derived<Type1>* d) const { visit(static_cast<Base*>(d)); };
    //...
    virtual void visit (Derived<TypeN>* d) const { visit(static_cast<Base*>(d)); };
};


struct FooVisitor : public Visitor
{
    virtual void visit (Base* base) const override
    {
        std::cout<<"visiting base class."<<std::endl;
    }

    //further definitions for those types that require a special implementation
    virtual void visit (Derived<TypeN>* d) const override
    {
        std::cout<<"visiting class of type Derived<TypeN>."<<std::endl;
    }
};

DEMO

---

编辑：这是使用基本double dispatch 的另一种可能性：

struct Visitor
{
    virtual ~Visitor() {}

    virtual void visit (Base*) const = 0;
};

struct FooVisitor : public Visitor
{
    virtual void visit (Base* base) const override
    {
        if(Derived<TypeN>* d = dynamic_cast<Derived<TypeN>*>(base))
        {
            std::cout<<"visiting class of type Derived<TypeN>."<<std::endl;
        }
        else
        {
            std::cout<<"visiting base class."<<std::endl;
        }
    }
};

它使您不必在基类中声明每个可能的变量类型，但可能不如以前的解决方案效率高。

这种蛮力方法还有一些其他的缺点，收集到in chapter 11 of Alexandrescu's book。您还可以阅读如何通过使用静态调度程序来克服这些缺点。基本上，您只需输入一次要考虑调度的类型，然后让代码创建上述逻辑。

DEMO