design pattern——observer

model

implement

target(subject)

typedef string State;
class Observer;

class Target
{
protected:
    Target();
    
public:
    virtual ~Target();
    
public:
    virtual void Attach(Observer* obv);
    virtual void Detach(Observer* obv);
    virtual void Notify();
    
public:
    virtual void SetState(const State& st) = 0;
    virtual State GetState() = 0;
    
private:
    list<Observer*>* _obvs;
};

Target::Target()
{
    _obvs = new list<Observer*>;
}

Target::~Target()
{
}

void Target::Attach(Observer *obv)
{
    _obvs->push_front(obv);
}

void Target::Detach(Observer *obv)
{
    if(obv)
    {
        _obvs->remove(obv);
    }
}

void Target::Notify()
{
    for(list<Observer*>::iterator iter = _obvs->begin(); iter != _obvs->end(); ++iter)
    {
        (*iter)->Update(this);
    }
}

concrete target(concrete subject)

class ConcreteTarget : public Target
{
public:
    ConcreteTarget();
    ~ConcreteTarget();
    
public:
    void SetState(const State& st);
    State GetState();
    
private:
    State _st;
};

ConcreteTarget::ConcreteTarget()
{
    _st = '\0';
}

ConcreteTarget::~ConcreteTarget()
{
}

void ConcreteTarget::SetState(const State& st)
{
    _st = st;
}

State ConcreteTarget::GetState()
{
    return _st;
}

observer

class Observer
{
protected:
    Observer();
    
public:
    virtual ~Observer();
    
public:
    virtual void Update(Target* target) = 0;
    virtual void PrintInfo() = 0;
    
protected:
    State _st;
};

Observer::Observer()
{
    _st = '\0';
}

Observer::~Observer()
{
}

concrete observer

class ConcreteObserverA : public Observer
{
public:
    ConcreteObserverA(Target* target);
    ~ConcreteObserverA();
    
public:
    void Update(Target* target);
    void PrintInfo();
    
public:
    virtual Target* GetTarget();
    
private:
    Target* _target;
};

class ConcreteObserverB : public Observer
{
public:
    ConcreteObserverB(Target* target);
    ~ConcreteObserverB();
    
public:
    void Update(Target* target);
    void PrintInfo();
    
public:
    virtual Target* GetTarget();
    
private:
    Target* _target;
};

ConcreteObserverA::ConcreteObserverA(Target* target)
{
    _target = target;
    _target->Attach(this);
}

ConcreteObserverA::~ConcreteObserverA()
{
    _target->Detach(this);
}

void ConcreteObserverA::Update(Target* target)
{
    _st = target->GetState();
    PrintInfo();
}

void ConcreteObserverA::PrintInfo()
{
    cout << "ConcreteObserverA..." << _target->GetState() <<  endl;
}

Target* ConcreteObserverA::GetTarget()
{
    return _target;
}

ConcreteObserverB::ConcreteObserverB(Target* target)
{
    _target = target;
    _target->Attach(this);
}

ConcreteObserverB::~ConcreteObserverB()
{
    _target->Detach(this);
}

void ConcreteObserverB::Update(Target* target)
{
    _st = target->GetState();
    PrintInfo();
}

void ConcreteObserverB::PrintInfo()
{
    cout << "ConcreteObserverB..." << _target->GetState() <<  endl;
}

Target* ConcreteObserverB::GetTarget()
{
    return _target;
}

应用

void observer_test()
{
    Target* target = new ConcreteTarget();
    
    Observer* obvA = new ConcreteObserverA(target);
    Observer* obvB = new ConcreteObserverB(target);
    
    target->SetState("old");
    target->Notify();
    target->SetState("new");
    target->Notify();
}

总结

• 抽象：concrete target的基类Target和concrete observer的公共基类Observer进行了抽象
• 扩展：concrete observer可以进行扩展
• 开发者不需要知道concrete target和concrete observer，开发者只需要与基类Target和公共基类Observer交互