访客模式+开放/封闭原则 [英] Visitor Pattern + Open/Closed Principle

问题描述

是否可以实现访问者模式，这个遵循开放/封闭原则，但仍然可以添加新的可访问课程？

开放/封闭原则指出，软件实体（类，模块，功能等）应该开放扩展，但关闭修改。

  struct ConcreteVisitable1; 
 struct ConcreteVisitable2; 
 
 struct AbstractVisitor 
 {
 virtual void visit（ConcreteVisitable1& concrete1）= 0; 
 virtual void visit（ConcreteVisitable2& concrete2）= 0; 
}; 
 
 struct AbstractVisitable 
 {
 virtual void accept（AbstractVisitor& visitor）= 0; 
}; 
 
 struct ConcreteVisitable1：AbstractVisitable 
 {
 virtual void accept（AbstractVisitor& visitor）
 {
 visitor.visit（* this）; 
} 
}; 
 
 struct ConcreteVisitable2：AbstractVisitable 
 {
 virtual void accept（AbstractVisitor& visitor）
 {
 visitor.visit（* this）; 
} 
}; 
  

您可以实现从AbstractVisitor派生的任意数量的类：它可以扩展。您不能添加一个新的可访问类，因为派生自AbstractVisitor的类将不会编译：它关闭以进行修改。

AbstractVisitor类树遵循Open / Closed原则。
AbstractVisitable类树不符合Open / Closed原则，因为它不能被扩展。

有没有其他解决方案来扩展AbstractVisitor和AbstractVisitable如下？

  struct ConcreteVisitable3; 
 
 struct AbstractVisitor2：AbstractVisitor 
 {
 virtual void visit（ConcreteVisitable3& concrete3）= 0; 
}; 
 
 struct AbstractVisitable2：AbstractVisitable 
 {
 virtual void accept（AbstractVisitor2& visitor）= 0; 
}; 
 
 struct ConcreteVisitable3：AbstractVisitable2 
 {
 virtual void accept（AbstractVisitor2& visitor）
 {
 visitor.visit（* this）; 
} 
}; 
  

解决方案

在C ++中，非循环访客（pdf）可以让您获得所需的。

Is it possible to implement the Visitor Pattern respecting the Open/Closed Principle, but still be able to add new visitable classes?

The Open/Closed Principle states that "software entities (classes, modules, functions, etc.) should be open for extension, but closed for modification".

struct ConcreteVisitable1;
struct ConcreteVisitable2;

struct AbstractVisitor
{
   virtual void visit(ConcreteVisitable1& concrete1) = 0;
   virtual void visit(ConcreteVisitable2& concrete2) = 0;
};

struct AbstractVisitable
{
   virtual void accept(AbstractVisitor& visitor) = 0;
};

struct ConcreteVisitable1 : AbstractVisitable
{
   virtual void accept(AbstractVisitor& visitor)
   {
      visitor.visit(*this);
   }
};

struct ConcreteVisitable2 : AbstractVisitable
{
   virtual void accept(AbstractVisitor& visitor)
   {
      visitor.visit(*this);
   }
};

You can implement any number of classes which derives from AbstractVisitor: It is open for extension. You cannot add a new visitable class as the classes derived from AbstractVisitor will not compile: It closed for modification.

The AbstractVisitor class tree respects the Open/Closed Principle. The AbstractVisitable class tree does not respect the Open/Closed Principle, as it cannot be extended.

Is there any other solution than to extend the AbstractVisitor and AbstractVisitable as below?

struct ConcreteVisitable3;

struct AbstractVisitor2 : AbstractVisitor
{
   virtual void visit(ConcreteVisitable3& concrete3) = 0;
};

struct AbstractVisitable2 : AbstractVisitable
{
   virtual void accept(AbstractVisitor2& visitor) = 0;
};

struct ConcreteVisitable3 : AbstractVisitable2
{
   virtual void accept(AbstractVisitor2& visitor)
   {
      visitor.visit(*this);
   }
};

解决方案

In C++, Acyclic Visitor (pdf) gets you what you want.

这篇关于访客模式+开放/封闭原则的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！