观察者模式C++实现

#include <iostream>
#include <vector>
#include <string>
using namespace std;
typedef string State;

class Observer;

// 目标
class Subject {
public:
    Subject() {}
    virtual ~Subject() {}

    virtual void Attach(Observer *pObserver);
    virtual void Detach(Observer *pObserver);
    virtual void Notify();
    virtual State GetState()=0;
    virtual void SetState(const State& nState)=0;
private:
    vector<Observer*> m_observers;
};

// 具体目标
class ConcreteSubject : public Subject {
public:
    ConcreteSubject() {}
    virtual ~ConcreteSubject() {}

    virtual State GetState();
    virtual void SetState(const State& nState);
private:
    State m_State;
};

// 观察者
class Observer {
public:
    Observer() {}
    virtual ~Observer(){}

    virtual void Update(Subject* pSubject)=0;
};

// 具体观察者
class ConcreteObserver : public Observer {
public:
    ConcreteObserver(string nSubjectName, Subject * pSubject);
    virtual ~ConcreteObserver();

    virtual void Update(Subject* pSubject);
private:
    string m_SubjectName;
    State m_State;
    Subject *m_pSubject;
};

// Subject
void Subject::Attach(Observer *pObserver) {
    m_observers.push_back(pObserver);
}
void Subject::Detach(Observer *pObserver) {
    for (vector<Observer*>::iterator iter = m_observers.begin(); iter != m_observers.end(); ++iter) {
        if (*iter == pObserver) {
            m_observers.erase(iter);
            return;
        }
    }
}
void Subject::Notify() {
    for (vector<Observer*>::iterator iter = m_observers.begin(); iter != m_observers.end(); ++iter) {
        (*iter)->Update(this);
    }
}

// ConcreteSubject
State ConcreteSubject::GetState() {
    return m_State;
}
void ConcreteSubject::SetState(const State& nState) {
    m_State = nState;
}

// ConcreteObserver
ConcreteObserver::ConcreteObserver(string nSubjectName, Subject * pSubject) {
    m_SubjectName = nSubjectName;
    m_pSubject = pSubject;
    m_pSubject->Attach(this);
}
ConcreteObserver::~ConcreteObserver() {
    m_pSubject->Detach(this);
    if (m_pSubject != 0) delete m_pSubject;
}
void ConcreteObserver::Update(Subject* pSubject) {
    m_State = pSubject->GetState();
    cout << "observer name: " << m_SubjectName << "    " << "state: " << m_State << endl;
}

int main() {
    ConcreteSubject * pConcreteSubject = new ConcreteSubject();
    Observer * o1 = new ConcreteObserver("observer1",pConcreteSubject);
    Observer * o2 = new ConcreteObserver("observer2",pConcreteSubject);
    pConcreteSubject->SetState("State_1");
    pConcreteSubject->Notify();
    pConcreteSubject->SetState("State_2");
    pConcreteSubject->Notify();
    return 0;
}