Question

在 Visitor 模式的典型实现中，该类必须考虑基类的所有变体（后代）。在许多情况下，访问者中的相同方法内容应用于不同的方法。在这种情况下，模板化的虚拟方法将是理想的，但目前，这是不允许的。

那么，可以使用模板化方法来解析父类的虚方法吗？

鉴于（基金会）：

struct Visitor_Base; // Forward declaration.

struct Base
{
  virtual accept_visitor(Visitor_Base& visitor) = 0;
};

// More forward declarations
struct Base_Int;
struct Base_Long;
struct Base_Short;
struct Base_UInt;
struct Base_ULong;
struct Base_UShort;

struct Visitor_Base
{
  virtual void operator()(Base_Int& b) = 0;
  virtual void operator()(Base_Long& b) = 0;
  virtual void operator()(Base_Short& b) = 0;
  virtual void operator()(Base_UInt& b) = 0;
  virtual void operator()(Base_ULong& b) = 0;
  virtual void operator()(Base_UShort& b) = 0;
};

struct Base_Int : public Base
{
  void accept_visitor(Visitor_Base& visitor)
  {
     visitor(*this);
  }
};

struct Base_Long : public Base
{
  void accept_visitor(Visitor_Base& visitor)
  {
     visitor(*this);
  }
};

struct Base_Short : public Base
{
  void accept_visitor(Visitor_Base& visitor)
  {
     visitor(*this);
  }
};

struct Base_UInt : public Base
{
  void accept_visitor(Visitor_Base& visitor)
  {
     visitor(*this);
  }
};

struct Base_ULong : public Base
{
  void accept_visitor(Visitor_Base& visitor)
  {
     visitor(*this);
  }
};

struct Base_UShort : public Base
{
  void accept_visitor(Visitor_Base& visitor)
  {
     visitor(*this);
  }
};

既然奠定了基础，那么这里就是踢球者（模板化方法）：

struct Visitor_Cout : public Visitor_Base
{
  template <class Receiver>
  void operator() (Receiver& r)
  {
     std::cout << "Visitor_Cout method not implemented.\n";
  }
};

有意地，Visitor_Cout在方法声明中不包含关键字virtual。方法签名的所有其他属性与父声明（或可能是规范）匹配。

总体而言，此设计允许开发人员实现常见的访问功能，这些功能仅根据目标对象（接收访问的对象）的类型而有所不同。上面的实现是我在派生的访问者实现没有实现可选方法时发出警报的建议。

C ++规范是否合法？

（当有人说它适用于编译器 XXX 时，我不相信。这是针对一般语言的问题。）

Answer 1

哦，我知道你在追求什么。尝试这样的事情：



template < typename Impl >
struct Funky_Visitor_Base : Visitor_Base
{
  // err...
  virtual void operator()(Base_Int& b) { Impl::apply(b) }
  virtual void operator()(Base_Long& b) { Impl::apply(b) }
  virtual void operator()(Base_Short& b) { Impl::apply(b) }
  virtual void operator()(Base_UInt& b) { Impl::apply(b) }
  virtual void operator()(Base_ULong& b) { Impl::apply(b) }

  // this actually needs to be like so:
  virtual void operator()(Base_UShort& b)
  {
    static_cast<impl *const>(this)->apply(b) 
  }
};

struct weird_visitor : Funky_Visitor_Base<weird_visitor>
{
  // Omit this if you want the compiler to throw a fit instead of runtime error.
  template < typename T >
  void apply(T & t)
  {
    std::cout << "not implemented.";
  }

  void apply(Base_UInt & b) { std::cout << "Look what I can do!"; }
};

那就是说，你应该研究非循环访客模式。它误解了构建在框架中的访问者，因此您不必为您永远不会调用的内容实现函数。

有趣的是，我实际上使用了与此类似的东西来构建一个类型列表的非循环访问者。我应用了一个元函数，它基本上构建了Funky_Visitor_Base并将一个运算符（像我显示的那样带有apply（）的东西）变成了一个完整列表的访问者。对象是反射性的，因此apply（）本身实际上是一个基于它所击中的任何类型构建的元函数。实际上很酷很奇怪。

Answer 2

在您的派生访客类Visitor_Cout中，operator()模板未覆盖operator()中的Visitor_Base。根据C ++ 03标准（14.5.2 / 4）：

成员函数模板的特化不会覆盖基类中的虚函数。 [实施例：

class B {
    virtual void f(int);
};

class D : public B {
    template <class T> void f(T);  // does not override B::f(int)
    void f(int i) { f<>(i); }      // overriding function that calls
                                   // the template instantiation
};

-end example]

访问者和模板化虚拟方法

那么，可以使用模板化方法来解析父类的虚方法吗？

C ++规范是否合法？

2 个答案: