：复合模式：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;

}