Modèle de conception C brève introduction au modèle de visiteur

Mode Visiteur (Visiteur) : Représente une opération qui agit sur chaque élément d'une structure d'objet. Il permet de définir de nouvelles opérations qui agissent sur ces éléments sans changer la classe de chaque élément.

Cinq classes de rôles :

Visiteur : déclare une opération Visit pour chaque classe de ConcreteElement dans la structure de l'objet.

ConcreteVistor : Un visiteur spécifique qui implémente chaque opération déclarée par le visiteur. Chaque opération implémente une partie de l'algorithme, et le fragment d'algorithme est une classe qui correspond à l'objet dans la structure.

ELement définit une opération Accept, qui prend un visiteur comme paramètre.

Élément spécifique à ConcreteElement, implémente l'opération Accept

ObjectStructure peut énumérer ses éléments et fournir une interface de haut niveau pour permettre aux visiteurs d'accéder à ses éléments.

Occasions applicables :

convient aux systèmes avec des structures de données relativement stables. Il découple le couplage entre la structure de données et les opérations qui agissent sur la structure de données, de sorte que l'ensemble des opérations puisse être une évolution relativement libre.

Le modèle de visiteur a pour objectif de séparer le traitement des structures de données. De nombreux systèmes peuvent être séparés en fonction d'algorithmes et de structures de données. Si un tel système a une structure de données relativement stable et un algorithme facile à modifier, il est plus approprié d'utiliser le mode visiteur, car le mode visiteur facilite l'augmentation. le nombre d'opérations de l'algorithme.

Les avantages :

L'avantage du mode visiteur est qu'il est facile d'ajouter de nouvelles opérations, car ajouter une nouvelle opération signifie ajouter un nouveau visiteur. Le modèle visiteur concentre les comportements associés dans un objet visiteur.

Ses inconvénients :

Rend difficile l'ajout de nouvelles structures de données.

Implémentation du modèle :

[code]class ConcreteElementA;
class ConcreteElementB;

class Visitor
{
public:
     virtual void VisitConcreteElementA(ConcreteElementA *pElementA) = 0;
     virtual void VisitConcreteElementB(ConcreteElementB *pElementB) = 0;
};

class ConcreteVisitor1 : public Visitor
{
public:
     void VisitConcreteElementA(ConcreteElementA *pElementA);
     void VisitConcreteElementB(ConcreteElementB *pElementB);
};

void ConcreteVisitor1::VisitConcreteElementA(ConcreteElementA *pElementA)
{
     // 现在根据传进来的pElementA，可以对ConcreteElementA中的element进行操作
}

void ConcreteVisitor1::VisitConcreteElementB(ConcreteElementB *pElementB)
{
     // 现在根据传进来的pElementB，可以对ConcreteElementB中的element进行操作
}

class ConcreteVisitor2 : public Visitor
{
public:
     void VisitConcreteElementA(ConcreteElementA *pElementA);
     void VisitConcreteElementB(ConcreteElementB *pElementB);
};

void ConcreteVisitor2::VisitConcreteElementA(ConcreteElementA *pElementA)
{
     // ...
}

void ConcreteVisitor2::VisitConcreteElementB(ConcreteElementB *pElementB)
{
     // ...
}

// Element object
class Element
{
public:
     virtual void Accept(Visitor *pVisitor) = 0;
};

class ConcreteElementA : public Element
{
public:
     void Accept(Visitor *pVisitor);
};

void ConcreteElementA::Accept(Visitor *pVisitor)
{
     pVisitor->VisitConcreteElementA(this);
}

class ConcreteElementB : public Element
{
public:
     void Accept(Visitor *pVisitor);
};

void ConcreteElementB::Accept(Visitor *pVisitor)
{
     pVisitor->VisitConcreteElementB(this);
}

// ObjectStructure类，能枚举它的元素，可以提供一个高层的接口以允许访问者访问它的元素
class ObjectStructure
{
public:
     void Attach(Element *pElement);
     void Detach(Element *pElement);
     void Accept(Visitor *pVisitor);

private:
     vector<Element *> elements;
};

void ObjectStructure::Attach(Element *pElement)
{
     elements.push_back(pElement);
}

void ObjectStructure::Detach(Element *pElement)
{
     vector<Element *>::iterator it = find(elements.begin(), elements.end(), pElement);
     if (it != elements.end())
     {
          elements.erase(it);
     }
}

void ObjectStructure::Accept(Visitor *pVisitor)
{
     // 为每一个element设置visitor，进行对应的操作
     for (vector<Element *>::const_iterator it = elements.begin(); it != elements.end(); ++it)
     {
          (*it)->Accept(pVisitor);
     }
}

Cas de test :

[code]int main()
{
     ObjectStructure *pObject = new ObjectStructure;

     ConcreteElementA *pElementA = new ConcreteElementA;
     ConcreteElementB *pElementB = new ConcreteElementB;

     pObject->Attach(pElementA);
     pObject->Attach(pElementB);

     ConcreteVisitor1 *pVisitor1 = new ConcreteVisitor1;
     ConcreteVisitor2 *pVisitor2 = new ConcreteVisitor2;

     pObject->Accept(pVisitor1);
     pObject->Accept(pVisitor2);

     if (pVisitor2) delete pVisitor2;
     if (pVisitor1) delete pVisitor1;
     if (pElementB) delete pElementB;
     if (pElementA) delete pElementA;
     if (pObject) delete pObject;

     return 0;
}

Ce qui précède est le contenu du modèle de conception C, brève introduction au modèle de visiteur. Pour un contenu plus connexe, veuillez faire attention au site Web PHP chinois (www.php.cn) !