:复合模式:duck
#ifndef __QUAKEABLE_H__ #define __QUAKEABLE_H__ #include <iostream> #include <vector> using namespace std; class QuackObservable; class Observer { public: Observer(){} virtual~Observer(){} virtual void update(QuackObservable *d) { cout << "Observer update " << endl; } }; class QuackObservable { public: QuackObservable(){} virtual ~QuackObservable(){} virtual void RegisterObserver(Observer *q1) { } virtual void NotifyObserver() { cout << "Notify Observer update " << endl; } }; class QuakeLogist:public Observer { public: QuakeLogist(){} virtual ~QuakeLogist(){} virtual void update(QuackObservable *d) { cout << "QuakeLogist update " << endl; } }; class ObserveAble : public QuackObservable { private: QuackObservable *q; vector<Observer*>olist; public: ObserveAble(QuackObservable *qq){ q = qq; } virtual ~ObserveAble(){} virtual void RegisterObserver(Observer *q1) { olist.push_back(q1); } virtual void NotifyObserver() { vector<Observer*>::iterator it = olist.begin(); while (it!= olist.end()) { (*it++)->update(q); } } }; class Quakeable :public QuackObservable { public: Quakeable(){} virtual~Quakeable(){} virtual void Quake(){} }; class MallardDuck :public Quakeable { private: ObserveAble *obseAble; public: MallardDuck() { obseAble = new ObserveAble(this); } virtual ~MallardDuck(){} virtual void Quake() { cout << "MallardDuck Quake" << endl; NotifyObserver(); } virtual void RegisterObserver(Observer *os) { obseAble->RegisterObserver(os); } virtual void NotifyObserver() { obseAble->NotifyObserver(); } }; class BlueDuck :public Quakeable { public: BlueDuck(){} virtual~BlueDuck(){} virtual void Quake() { cout << "Blue Duck Quake" << endl; } }; class RedDuck :public Quakeable { public: RedDuck(){} virtual~RedDuck(){} virtual void Quake() { cout << "Red Duck Quake" << endl; } }; class DuckCall :public Quakeable { public: DuckCall(){} virtual~DuckCall(){} virtual void Quake() { cout << "DuckCall Quake" << endl; } }; class RubberDuck :public Quakeable { public: RubberDuck(){} virtual~RubberDuck(){} virtual void Quake() { cout << "Rubber Duck Quake" << endl; } }; class QuackCounter :public Quakeable { private: Quakeable *duck; static int number; public: QuackCounter(Quakeable *q) { duck = q; } virtual~QuackCounter(){} virtual void Quake() { duck->Quake(); number++; } static int getNum() { return number; } }; int QuackCounter::number = 0; #endif
#ifndef __GOOSE_H__ #define __GOOSE_H__ #include "Quakable.h" class Goose { public: Goose(){} virtual~Goose(){} virtual void honk() { cout << "Goose honk" << endl; } }; class GooseAdapter :public Quakeable { private: Goose *goose; public: GooseAdapter(Goose *g) { goose = g; } virtual~GooseAdapter(){} virtual void Quake() { goose->honk(); } }; class AbDuckFactory { public: AbDuckFactory(){} virtual~AbDuckFactory(){} virtual Quakeable * CreateBlueDuck() = 0; virtual Quakeable * CreateRedDuck() = 0; virtual Quakeable * CreateCallDuck() = 0; virtual Quakeable * CreateRubberDuck() = 0; }; class DuckFactory : public AbDuckFactory { public: DuckFactory(){} virtual~DuckFactory(){} virtual Quakeable * CreateBlueDuck() { return new BlueDuck(); } virtual Quakeable * CreateRedDuck(){ return new RedDuck(); } virtual Quakeable * CreateCallDuck() { return new DuckCall(); } virtual Quakeable * CreateRubberDuck() { return new RubberDuck(); } }; class CountFactory : public AbDuckFactory { public: CountFactory(){} virtual~CountFactory(){} virtual Quakeable * CreateBlueDuck() { return new QuackCounter(new BlueDuck()); } virtual Quakeable * CreateRedDuck(){ return new QuackCounter(new RedDuck()); } virtual Quakeable * CreateCallDuck() { return new QuackCounter(new DuckCall()); } virtual Quakeable * CreateRubberDuck() { return new QuackCounter(new RubberDuck()); } }; class DuckFlock :public Quakeable { private: ObserveAble *obs; vector<Quakeable *> ducklist; public: DuckFlock() { obs = new ObserveAble(this); } virtual~DuckFlock(){} void add(Quakeable *t) { ducklist.push_back(t); } virtual void Quake() { vector<Quakeable*>::iterator it = ducklist.begin(); while (it != ducklist.end()) { (*it++)->Quake(); NotifyObserver(); } } virtual void RegisterObserver(Observer *ob) { obs->RegisterObserver(ob); } virtual void NotifyObserver() { obs->NotifyObserver(); } }; #endif
#include <iostream> #include "Quakable.h" #include "Goose.h" using namespace std; void simulate() { AbDuckFactory *f = new CountFactory(); Quakeable *r = f->CreateBlueDuck(); Quakeable *b =f->CreateCallDuck(); Quakeable *d = f->CreateRedDuck(); Quakeable *rub = f->CreateRubberDuck(); Quakeable *g = new QuackCounter(new GooseAdapter(new Goose())); r->Quake(); b->Quake(); d->Quake(); rub->Quake(); g->Quake(); cout << "Fuck " << QuackCounter::getNum() << endl; Quakeable *r1 = f->CreateBlueDuck(); Quakeable *r2 = f->CreateBlueDuck(); Quakeable *r3 = f->CreateBlueDuck(); Quakeable *r4 = f->CreateBlueDuck(); DuckFlock *df = new DuckFlock(); df->add(r1); df->add(r2); df->add(r3); df->add(r4); cout << "Fuck " << QuackCounter::getNum() << endl; QuakeLogist *ql = new QuakeLogist(); // Quakeable *qa = new MallardDuck(); // qa->RegisterObserver(ql); // qa->Quake(); df->RegisterObserver(ql); df->Quake(); } int main() { simulate(); return 0; }