10

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

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

给定（基础）：

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一起使用。这是一个针对通用语言的问题。）

4

2 回答 2

6

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



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() 本身实际上是一个基于它所击中的任何类型构建的元函数。实际上很酷很奇怪。

于 2010-05-21T23:28:37.270 回答
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
};

——结束示例]

于 2010-05-21T23:24:34.960 回答