Head first design patterns c++实现, observer

//observer.h            observer interface

#ifndef OBSERVER_H__
#define OBSERVER_H__

class Observer {
public:
 Observer(){}
 virtual ~Observer(){}
 virtual void Update() = 0;

private:
 Observer(const Observer&){}
 Observer& operator=(const Observer&){}
};

#endif

//subject.h         subject interface

#ifndef SUBJECT_H__
#define SUBJECT_H__

#include "observer.h"
#include <vector>

class Subject {
public:
 Subject() : it(observers.begin()) {}
 virtual ~Subject() {}
 void RegisterOb(Observer*);
 void RemoveOb(const Observer*);
 void NotifyOb();
 

private:
 Subject(const Subject&){}
 Subject& operator=(const Subject&){}
 std::vector<Observer*> observers;
 std::vector<Observer*>::iterator it;
};

#endif

//subject.cpp 

#include "subject.h"
#include <algorithm>
using namespace std;

void Subject::RegisterOb(Observer *ob)
{
 observers.push_back(ob);
}

void Subject::RemoveOb(const Observer *ob)
{
 it = find(observers.begin(),observers.end(),ob);
 if ( it != observers.end())
  observers.erase(it);
}

void Subject::NotifyOb()
{
 for( it = observers.begin(); it != observers.end(); ++it )
  (*it)->Update();
}
 

//weatherdata.h       concrete subject

#ifndef WEATHERDATA_H__
#define WEATHERDATA_H__

#include "subject.h"

typedef double temperature;
typedef double humidity;
typedef unsigned int pressure;

class WeatherData : public Subject {
public:
 WeatherData():temp(0),hum(0),pre(0){}
 WeatherData(temperature t, humidity h, pressure p):temp(p),hum(h),pre(p){}
 WeatherData& operator=(const WeatherData&);
  
 temperature getTemperature() { return temp; }
 humidity getHumidity() { return hum; }
 pressure getPressure() { return pre;  }
 void MeasurementsChanged() { Subject::NotifyOb(); }
 void SetMeasurements(temperature, humidity, pressure);

private:
 WeatherData(const WeatherData&);
 temperature temp;
 humidity hum;
 pressure pre;
};

inline WeatherData& WeatherData::operator =(const WeatherData& rhs)
{
 temp = rhs.temp;
 hum = rhs.hum;
 pre = rhs.pre;
 return *this;
}

inline void WeatherData::SetMeasurements(temperature t, humidity h, pressure p)

{ 
 temp = t;
 hum = h;
 pre = p;
 MeasurementsChanged();
}

#endif

//displayelement.h          display interface

#ifndef DISPLAYELEMENT_H__ 
#define DISPLAYELEMENT_H__

class DisplayElement {
public:
 DisplayElement(){}
 virtual void Display() = 0;

private:
 DisplayElement(const DisplayElement&){}
 DisplayElement& operator=(const DisplayElement&){}
};

#endif

//ccdisplay.h         concrete display and concrete observer

#ifndef CCDISPLAY_H__
#define CCDISPLAY_H__

#include "weatherdata.h"
#include "observer.h"
#include "displayelement.h"

typedef double temperature;
typedef double humidity;

class CurrentConditionDisplay : private Observer, private DisplayElement {
public:
 CurrentConditionDisplay(WeatherData&);
 void Update();
 void Display();

private:
 CurrentConditionDisplay(const CurrentConditionDisplay&){}
 CurrentConditionDisplay operator=(const CurrentConditionDisplay&){}
 temperature temp;
 humidity hum;
 WeatherData* pwd;
};

#endif

//ccdisplay.cpp

#include "ccdisplay.h"
#include <iostream>
using namespace std;

CurrentConditionDisplay::CurrentConditionDisplay(WeatherData& wd)
{
 pwd = &wd;
 wd.RegisterOb(this);
}

void CurrentConditionDisplay::Update()
{
 temp = pwd->getTemperature();
 hum = pwd->getHumidity();
 Display();
}

void CurrentConditionDisplay::Display()
{
 cout << "Current Conditions: " << temp << "F degrees and "
     << hum << "% humidity" << endl;
}

//fdisplay.h            concrete display and concrete observer

#ifndef FDISPLAY_H__
#define FDISPLAY_H__

#include "weatherdata.h"
#include "observer.h"
#include "displayelement.h"

class ForecastWeatherDisplay : private Observer, private DisplayElement{
public:
 ForecastWeatherDisplay(WeatherData&);
 void Update();
 void Display();

private:
 ForecastWeatherDisplay(ForecastWeatherDisplay&);
 ForecastWeatherDisplay& operator=(const ForecastWeatherDisplay&);
 WeatherData* pwd;
};
 

#endif

//fdisplay.cpp

#include "fdisplay.h"
#include <iostream>
using namespace std;

ForecastWeatherDisplay::ForecastWeatherDisplay(WeatherData &wd)
{
 pwd = &wd;
 wd.RegisterOb(this);
}

void ForecastWeatherDisplay::Display()
{
 cout << "Improving weather on the way!/n";
}

void ForecastWeatherDisplay::Update()
{
 Display();
}

//main.cpp

#include "weatherdata.h"
#include "ccdisplay.h"
#include "fdisplay.h"

int main()
{
 WeatherData w;
 CurrentConditionDisplay d(w);
 ForecastWeatherDisplay f(w);

 w.SetMeasurements(80.1, 60.3, 30);
 return 0;
}