使用访问者模式重构代码

Question

我在尝试重构代码时遇到问题。它位于类似编译器的结构中。 代码结构如下。 我有几个目标平台来生成我的代码，比如 x86。

class Op
{
public:
  virtual doA(vector<int>& vec) = 0;
  virtual doB(unordered_map<int>& map) = 0;
};

---Directory x86----
class X86_Op_A: public Op 
{
public:
  virtual doA(vector<int>& vec){
      // genereate A type operator that do something under x86
  }
  virtual doB(unordered_map<int>& map){
     // genereate A type operator that do something under x86
  }
};

class X86_Op_B: public Op
public:
  virtual doA(vector<int>& vec){
      // genereate B type operator that do something under x86
  }
  virtual doB(unordered_map<int>& map){
     // genereate B type operator that do something under x86
  }
}; 

---Director arm---
class Arm_Op_A: public Op 
class Arm_Op_B: public Op
like the same code described above.

我如何重构代码，使它们看起来像访问者模式，我可以给它我的目标平台和我想做的操作。

我曾尝试考虑编写一个抽象的平台接口并使用不同的目标平面图实现。但是，我仍然觉得很难正确编写代码。如果在这种情况下我不能使用访问者模式，有没有办法重构代码？

Answer 1

我希望这会有所帮助！

如果满足以下条件，访问者模式会更好： 1 - 出于某种原因，您想将 doA 和 doB 操作分开在不同的类中； 2 - 您的 X86_Op_A、X86_Op_B、Arm_Op_A、Arm_Op_B 类有其他方法，您不希望 doA 和 doB 操作与这些方法一起使用；

class X86_Op_A;
class X86_Op_B;
class Arm_Op_A;
class Arm_Op_B;

class OpVisitor
{
public:
    OpVisitor();
    virtual ~OpVisitor();
public:
    virtual void visit(X86_Op_A*) = 0;
    virtual void visit(X86_Op_B*) = 0;
    virtual void visit(Arm_Op_A*) = 0;
    virtual void visit(Arm_Op_B*) = 0;
};

#include "OpVisitor.h"
#include "vector"
#include "iostream"

class DoAVisitor :
    public OpVisitor
{
public:
    DoAVisitor(std::vector<int>& vec): m_vec(vec)
    {
    }
    virtual ~DoAVisitor();
public:
    virtual void visit(X86_Op_A*)
    {
        std::cout << "genereate A type operator that do something under x86" << "\n";
    }
    virtual void visit(X86_Op_B*)
    {
        std::cout << "genereate B type operator that do something under x86" << "\n";
    }
    virtual void visit(Arm_Op_A*)
    {
        std::cout << "genereate A type operator that do something under Arm" << "\n";
    }
    virtual void visit(Arm_Op_B*)
    {
        std::cout << "genereate B type operator that do something under x86" << "\n";
    }
protected:
    std::vector<int>& m_vec;
};

#include "OpVisitor.h"
#include "iostream"
#include "unordered_map"

class DoBVisitor :
    public OpVisitor
{
public:
    DoBVisitor(std::unordered_map<int, int>& map): m_map(map)
    {
    }
    virtual ~DoBVisitor();
public:
    virtual void visit(X86_Op_A*)
    {
        std::cout << "genereate A type operator that do something under x86" << "\n";
    }
    virtual void visit(X86_Op_B*)
    {
        std::cout << "genereate B type operator that do something under x86" << "\n";
    }
    virtual void visit(Arm_Op_A*)
    {
        std::cout << "genereate A type operator that do something under Arm" << "\n";
    }
    virtual void visit(Arm_Op_B*)
    {
        std::cout << "genereate B type operator that do something under x86" << "\n";
    }
protected:
    std::unordered_map<int, int>& m_map;
};

#include "Op.h"
#include "OpVisitor.h"

class X86_Op_A :
    public Op
{
public:
    X86_Op_A();
    virtual ~X86_Op_A();
public:
    virtual void Accept(OpVisitor& v)
    {
        v.visit(this);
    }
};

#include "Op.h"
#include "OpVisitor.h"

class X86_Op_B :
    public Op
{
public:
    X86_Op_B();
    virtual ~X86_Op_B();
public:
    virtual void Accept(OpVisitor& v)
    {
        v.visit(this);
    }
};

#include <iostream>
#include "X86_Op_A.h"
#include "DoAVisitor.h"
#include "vector"

int main()
{
    X86_Op_A var;

    std::vector<int> vec;

    DoAVisitor visitor(vec);

    var.Accept(visitor);

    std::cout << "Hello World!\n"; 
}