#include <iostream>

#include <assert.h>

#include <list>

class Observer

{

public:

	virtual ~Observer() = 0

	{

	}

	virtual void update(float, float, float) = 0;

};

class Subject

{

public:

	virtual ~Subject() = 0

	{

	}

	virtual void registerObserver(Observer *) = 0;

	virtual void removeObserver(Observer *) = 0;

	virtual void notifyObserver() const = 0;

};

class CurrentCondition :public Observer

{

public:

	CurrentCondition() :m_temperature(0.0), m_humidity(0.0)

	{

	}

	~CurrentCondition()

	{

	}

	void update(float temperature, float humitity, float pressure)

	{

		m_temperature = temperature;

		m_humidity = humitity;

		m_pressure = pressure;

		display();

	}

	void  display()

	{

		std::cout.setf(std::ios::showpoint);

		std::cout.precision(3);

		std::cout << "Current condition " << m_temperature;

		std::cout << "C, and " << m_humidity << "% humidity" << std::endl;

	}

private:

	float m_temperature;

	float m_humidity;

	float m_pressure;

};

class ForecastCondition :public Observer

{

public:

	ForecastCondition() :m_currentPressure(0.0), m_lastPressure(0.0)

	{

	}

	~ForecastCondition()

	{

	}

	void update(float temperature, float humitity, float pressure)

	{

		m_lastPressure = m_currentPressure;

		m_currentPressure = pressure;

		display();

	}

	void  display()

	{

		std::cout.setf(std::ios::showpoint);

		std::cout.precision(3);

		std::cout << "Current condition " << m_temperature;

		std::cout << "C, and " << m_humidity << "% humidity" << std::endl;

	}

private:

	float m_temperature;

	float m_humidity;

	float m_pressure;

	float m_lastPressure;

	float m_currentPressure;

};

class WeatherData :public Subject

{

public:

	WeatherData() :m_temperature(0.0), m_humidity(0.0), m_pressure(0.0)

	{

	}

	~WeatherData()

	{

	}

	void registerObserver(Observer *o)

	{

		assert(o);

		m_observers.push_back(o);

	}

	void removeObserver(Observer *o)

	{

		m_observers.remove(o);

	}

	void notifyObserver()const

	{

		for (std::list<Observer *>::const_iterator it = m_observers.begin(); it != m_observers.end(); ++it)

		{

			Observer *obj = *it;

			obj->update(m_temperature, m_humidity, m_pressure);

		}

	}

	void setMeasurements(float temperature, float humitity, float pressure)

	{

		m_temperature = temperature;

		m_humidity = humitity;

		m_pressure = pressure;

	}

private:

	float m_temperature;

	float m_humidity;

	float m_pressure;

	std::list<Observer*> m_observers;

private:

	WeatherData(const WeatherData&);

};

int main()

{

	CurrentCondition current;

	ForecastCondition forecast;

	WeatherData weatherdata;

	weatherdata.registerObserver(&current);

	weatherdata.registerObserver(&forecast);

	weatherdata.setMeasurements(14, 65, 30.4f);

	weatherdata.setMeasurements(19, 70, 29.2f);

	weatherdata.setMeasurements(12, 90, 29.2f);

	system("pause");

	return 0;

}

#include <iostream>

#include <assert.h>

#include <memory>

class FlyBehavior//飞的抽象类

{

public:

	virtual ~FlyBehavior() = 0

	{

	}

	virtual void fly() const = 0;

};

class FlyNoWay :public FlyBehavior//不会飞

{

public:

	void fly() const

	{

		std::cout << "I can't fly" << std::endl;

	}

};

class FlyRocketPowered :public FlyBehavior//火箭飞

{

public:

	void fly() const

	{

		std::cout << "I'm flying with a rocket" << std::endl;

	}

};

class FlyWithWings :public FlyBehavior//翅膀飞

{

public:

	void fly() const

	{

		std::cout << "I'm flying" << std::endl;

	}

};

class QuackBehavior//叫的抽象类

{

public:

	virtual ~QuackBehavior() = 0

	{

	}

	virtual void quack() const = 0;

};

class FakeQuack :public QuackBehavior//假叫

{

public:

	void quack() const

	{

		std::cout << "Qwak" << std::endl;

	}

};

class MuteQuack :public QuackBehavior//不叫

{

public:

	void quack() const

	{

		std::cout << "Silence" << std::endl;

	}

};

class Quack :public QuackBehavior//嘎

{

public:

	void quack() const

	{

		std::cout << "Quack" << std::endl;

	}

};

class Squeak :public QuackBehavior//吱

{

public:

	void quack() const

	{

		std::cout << "Squeak" << std::endl;

	}

};

class Duck//鸭的抽象类

{

public:

	void setFlyBehavior(FlyBehavior *fb)

	{

		assert(fb);

		_flyBehavior = std::auto_ptr<FlyBehavior>(fb);

	}

	void setQuackBehavior(QuackBehavior *qb)

	{

		assert(qb);

		_quackBehavior = std::auto_ptr<QuackBehavior>(qb);

	}

	void performFly() const

	{

		_flyBehavior->fly();

	}

	void performQuack() const

	{

		_quackBehavior->quack();

	}

	void swim() const

	{

		std::cout << "All ducks float, even decoys!" << std::endl;

	}

	virtual void display() const = 0;

protected:

	Duck(FlyBehavior *flyBehavior, QuackBehavior *quackBehavior) :_flyBehavior(flyBehavior), _quackBehavior(quackBehavior)

	{

		assert(flyBehavior);

		assert(quackBehavior);

	}

	virtual ~Duck()

	{

	}

private:

	std::auto_ptr<FlyBehavior>_flyBehavior;//智能指针

	std::auto_ptr<QuackBehavior>_quackBehavior;

	Duck(const Duck&);//Disable copy constructor

	void operator=(const Duck&);//Disable assignment operator

};

class DecoyDuck :public Duck//诱饵鸭

{

public:

	DecoyDuck() :Duck(new FlyNoWay(), new MuteQuack())

	{

	}

	void display() const

	{

		std::cout << "I'm a duck Decoy" << std::endl;

	}

};

class MallardDuck :public Duck//野鸭

{

public:

	MallardDuck() :Duck(new FlyWithWings(), new Quack())

	{

	}

	void display() const

	{

		std::cout << "I'm a real Mallard duck" << std::endl;

	}

};

class ModeldDuck :public Duck//假鸭

{

public:

	ModeldDuck() :Duck(new FlyNoWay(), new FakeQuack())

	{

	}

	void display() const

	{

		std::cout << "I'm a model duck" << std::endl;

	}

};

class RedHead :public Duck//红头鸭

{

public:

	RedHead() :Duck(new FlyWithWings(), new Quack())

	{

	}

	void display() const

	{

		std::cout << "I'm a real Red Head duck" << std::endl;

	}

};

class RubberDuck :public Duck//橡皮鸭

{

public:

	RubberDuck() :Duck(new FlyNoWay(), new Squeak())

	{

	}

	void display() const

	{

		std::cout << "I'm a rubber duck" << std::endl;

	}

};

int main()

{

	std::auto_ptr<MallardDuck>mallard(new MallardDuck());

	std::auto_ptr<RubberDuck>rubberduck(new RubberDuck());

	std::auto_ptr<DecoyDuck>decoy(new DecoyDuck());

	std::auto_ptr<ModeldDuck>model(new ModeldDuck());

	mallard->performFly();

	mallard->performQuack();

	rubberduck->performFly();

	rubberduck->performQuack();

	decoy->performFly();

	decoy->performQuack();

	model->performFly();

	model->performQuack();

	model->setFlyBehavior(new FlyRocketPowered());

	model->performFly();

	system("pause");

	return 0;

}