Mencoba Visitor Pattern.

Visitor, pengunjung. Visitor pattern menggunakan prisip open/close dalam desain sebuah program. Pattern ini memisahkan “sebuah operasi -tindakan/algoritma” dari objek. Terdapat dua objek: Visitor dan Objek yang bisa dikunjungi (visitable objek). Kelihatannya Pattern ini mirip dengan strategi pattern: memisahkan algoritma dari kelas menjadi kelas yang lain. Namun Visitor Pattern dan strategi pattern berbeda.

Strategy pattern

AlgoritmaX adalah abstract class. punya method Count()

AlgoritmaX1 turunan AlgoritmaX. AlgoritmaX1 mengimplementasikan method Count() dengan algoritma tertentu

AlgoritmaX2 turunan AlgoritmaX. AlgoritmaX2 mengimplementasikan method Count() dengan algoritma tertentu

AlgoritmaX3 turunan AlgoritmaX. AlgoritmaX3 mengimplementasikan method Count() dengan algoritma tertentu

objek A punya algoritmaX1.

objek B punya algoritmaX2.

objek C punya algoritmaX3.

Baik A,B,C memangggil Count(). pemanggilannya sama , namun menggunakan algoritma berbeda. Jadi dengan menggunakan strategy pattern, Count() di implementasikan secara berbeda. Dan kelas pengguna algoritma (dalam hal ini : objek A, objek B, objek C) bisa melakukan pergantian algoritma secara mudah (karena dipisah).

Visitor Pattern

Visitor adalah abstract class.memiliki beberapa method Visit(). Misal Visit(objectA* ), Visit(objectB*)

Visitable adalah abstract class. memiliki method Accept(visitor).

Concrete Visitor turunan visitor yang mengimplementasikan method Visit()

Concrete Visitable turunan Visitable yang mengimplementasikan method Accept()

Bagaimana bekerjanya: setiap Accept() melewatkan object visitor, di dalam method Accept() : method Visit() di panggil dan melewatkan instan objek yang memiliki method accept() tadi. Contoh code dibawah ini cukup mewakili kata-kata ga jelas saya :p .

[sourcecode language=“cpp”] #include #include

using namespace std;

class visitor;

/* visitable object, abstract class */ class VisitableObject { public: virtual void accept(visitor& v) = 0; };

/* object A*/ class ObjectA :public VisitableObject { public: ObjectA() :mID(0), mName(“defaultName”) { } string getName() { return mName; } int getId() { return mID; } virtual void accept(visitor& v);

private: int mID; string mName; };

/* object B */ class ObjectB: public ObjectA { public: ObjectB():ObjectA() { } void accept(visitor& v); };

/* object C */ class ObjectC: public ObjectA { public: ObjectC():ObjectA() { } void accept(visitor& v); };

/* pure abstract class / class visitor { public: virtual void visit(ObjectA a)=0; virtual void visit(ObjectB* b)=0; virtual void visit(ObjectC* c)=0; };

//implementation. should be here.(below visitor class declaration) void ObjectA::accept(visitor& v) { v.visit(this); } //implementation. should be here.(below visitor class declaration) void ObjectB::accept(visitor& v) { v.visit(this); } //implementation. should be here.(below visitor class declaration) void ObjectC::accept(visitor& v) { v.visit(this); }

/* visitor that implement printing / class printVisitor:public visitor { public: void visit(ObjectA a) { cout«“Name A: “«a->getName()«endl; cout«“ID A: “«a->getId()«endl; } void visit(ObjectB* b) { cout«“Name B: “«b->getName()«endl; cout«“ID B: “«b->getId()«endl; } void visit(ObjectC* c) { cout«“Name C: “«c->getName()«endl; cout«“ID C: “«c->getId()«endl; } };

int main() { cout«“Visitor pattern test”«endl; ObjectA* A=new ObjectA(); ObjectB* B=new ObjectB(); ObjectC* C=new ObjectC();

printVisitor* pv=new printVisitor();

A->accept(*pv);
B->accept(*pv);
C->accept(*pv);
system("pause");

} [/sourcecode]

Output Program:

Visitor Pattern test
Name A: defaultName
ID A: 0
Name B: defaultName
ID B: 0
Name C: defaultName
ID C: 0
Press any key to continue . . .

Objek A, B, C adalah objek yang visitable. Sedangkan printVisitor adalah konkret visitor. Ketika A->accept(*pv)  dipanggil , printVisitor dilewatkan melalui accept(*pv).

void ObjectA::accept(visitor& v) {       v.visit(this); }

Di dalam method accept, instan kelas dari A dilewatkan ke visitor v.visit(this) untuk diproses lebih lanjut.