рефакторинг коды с использованием шаблона посетителя

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"; 
}