Eine kurze Einführung in Besuchermuster in C++-Entwurfsmustern

Besuchermodus (Besucher): Stellt eine Operation dar, die auf jedes Element in einer Objektstruktur wirkt. Er ermöglicht es Ihnen, neue Operationen zu definieren, die auf diese Elemente wirken, ohne die Klasse jedes Elements zu ändern.

Fünf Rollenklassen:

Visitor: Deklariert eine Visit-Operation für jede Klasse von ConcreteElement in der Objektstruktur.

ConcreteVistor: Ein bestimmter Besucher, der jeden vom Besucher deklarierten Vorgang implementiert. Jede Operation implementiert einen Teil des Algorithmus, und das Algorithmusfragment ist eine Klasse, die dem Objekt in der Struktur entspricht.

ELement definiert eine Accept-Operation, die einen Besucher als Parameter akzeptiert.

ConcreteElement-spezifisches Element, implementiert den Accept-Vorgang

ObjectStructure kann seine Elemente aufzählen und eine High-Level-Schnittstelle bereitstellen, um Besuchern den Zugriff auf seine Elemente zu ermöglichen.

Anwendbare Anlässe:

eignet sich für Systeme mit relativ stabilen Datenstrukturen. Es entkoppelt die Kopplung zwischen der Datenstruktur und den Operationen, die auf die Datenstruktur einwirken, sodass der Operationssatz relativ sein kann kostenlos.

Der Zweck des Besuchermusters besteht darin, die Verarbeitung von Datenstrukturen zu trennen. Viele Systeme können nach Algorithmen und Datenstrukturen getrennt werden. Wenn ein solches System über eine relativ stabile Datenstruktur und einen leicht zu ändernden Algorithmus verfügt, ist es sinnvoller, den Besuchermodus zu verwenden, da der Besuchermodus eine einfache Erhöhung ermöglicht die Anzahl der Algorithmusoperationen.

Die Vorteile:

Der Vorteil des Besuchermodus besteht darin, dass das Hinzufügen neuer Vorgänge einfach ist, da das Hinzufügen eines neuen Vorgangs das Hinzufügen eines neuen Besuchers bedeutet. Das Besuchermuster konzentriert verwandte Verhaltensweisen in einem Besucherobjekt.

Seine Nachteile:

Erschwert das Hinzufügen neuer Datenstrukturen.

Musterimplementierung:

[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);
     }
}

Testfall:

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

Das Obige ist der Inhalt des C++-Designmusters, eine kurze Einführung in das Besuchermuster. Weitere verwandte Inhalte finden Sie hier. Bitte achten Sie auf die chinesische PHP-Website (www.php.cn)!