从访客模式返回一个值

Question

我的层次结构如下：

         class Element{ public : virtual void Accept(Visitor&) = 0
                 protected : Element();   int num;
          };

         class ElementA : public Element{
                 public : ElementA(); 
                 void Accept(Visitor& v) {v.Visit(this};}
         };

         class ElementB : public Element{
                 public : ElementB(); 
                 void Accept(Visitor& v) {v.Visit(this};}


         class Visitor{
                 public: void Visit(ElementA*);
                 void Visit(ElementB*);
         };

编辑： 需要将方法 int getNum() 添加到将提供 num 值的层次结构中。但是，这需要重新编译整个层次结构，我们不允许这样做。所以我们必须以某种方式改变层次结构的设计，以便不需要重新编译层次结构。

Answer 1

您想要做的事情不可能以一种设计简洁的方式实现。我不知道，为什么完全重新编译该层次结构会是这样一个问题，但是有一个解决方案在技术上是可行的，而无需使用像reinterpret_casting 访问保护和其他黑客这样的 UB 黑客。

int Visitor::getNum(Element* pe)
{ 
  //define a pick-pocket... ;)
  struct ElementNumAccessor : private Element
  {
    ElementNumAccessor(Element const& e) : Element(e) {}   
    int getNum() { return num; }

    void Accept(Visitor&); //has to be declared, but needs not be defined
  };

  //...and let him work:
  ElementNumAccessor ea(*pe);
  return ea.getNum();
}

这个灵魂在行动：http://ideone.com/e1chSX
这利用了受保护的访问是可传递的这一事实，但以牺牲您想要 num 的每个元素的副本为代价。我将 struct 设为函数本地类，因此没有人会想到将其实际用于任何其他目的。

但请记住，这种技术是一种 hack，是对不应该以这种方式使用的语言功能的利用。

我的建议是：如果您的层次结构在程序中如此纠缠，以至于更改它会导致重新编译恐惧，那么是时候重构您的程序以减少编译时依赖性，然后进行您必须做的更改。

Answer 2

您的问题是如何允许类 (Visitor) 直接访问在不同类层次结构 (Elements) 中继承的私有数据成员。

一个快速的答案是：不要！这将破坏可见性修饰符的全部目的。 但是这样做是 still possible 使用 friend （导致重新编译层次结构）或通过指针重新解释。

一个干净的解决方案是使用adapter pattern（使用继承）将整个Elements 层次结构复制到另一个存根层次结构中，该存根层次结构提供与对应函数的委托完全相同的接口，为num 提供getter 函数并将新的层次结构与您的访问者一起使用，该访问者将能够通过 getter 访问 num。

Answer 3

不是访问者模式方面的专家，但这符合您的要求吗？

    class Element{ public : virtual void Accept(Visitor&) = 0
             protected : Element();   int num;
      };

     class ElementA : public Element{
             public : ElementA(); 
             void Accept(Visitor& v) {v.setNum(this->num); v.Visit(this);}
     };

     class ElementB : public Element{
             public : ElementB(); 
             void Accept(Visitor& v) {v.setNum(this->num); v.Visit(this);}


     class Visitor{
             public:
             void Visit(ElementA*);
             void Visit(ElementB*);
             void setNum(int _num) {num = _num;}
             int getNum() {return num;}

             private:
             int num;
     };

Answer 4

一种可能性是将GetNumVisitor 声明为Element class 的朋友并直接访问num 成员变量。然后在GetNumVisitor中添加一个方法返回值。

class Element { 
  ...
  friend GetNumVisitor;  // declare GetNumVisitor as a friend class
  ...
};

GetNumVisitor : public Visitor {
 private: 
  int  m_numelement;
 public : 
  void visit(Element *E) { m_elementNum = E->num; }
  int getNum() const { return m_elementNum;}
};

你必须把它称为

 ElementA element_a();
 ElementB element_b();
 GetNumVisitor getnumVisitor();
 element_a.accept(getnumVisitor);
 int a = getnumVisitor.getNum();
 element_b.accept(getNumVisitor);
 int b = getnumVisitor.getNum();
 ...