观察者模式例子

c9.h

#include <vector>

class Observer;

class Subject {
public:
        virtual void mregister(Observer* observer) = 0;
        virtual void remove(Observer* observer) = 0;
        virtual void notify() = 0;
        virtual ~Subject() {}
};

class ConcreteSubject: public Subject {
private:
        std::vector<Observer *> observer_list;
        int state;
        int state2;
public:
        void mregister(Observer* observer);
        void remove(Observer* observer);
        void notify();

        int getState();
        void setState(const int state);

        int getState2();
        void setState2(const int state);
        ConcreteSubject();
};

class Observer {
public:
        virtual void doUpdate(ConcreteSubject* subject) = 0;
};

class ConcreteObserver: public Observer {
public:
        void doUpdate(ConcreteSubject* subject);
        void update(const int state);
        void displayInformation(const int state);
};

class ConcreteObserver2: public Observer {
public:
        void doUpdate(ConcreteSubject* subject);
        void update(const int state1, const int state2);
        void displayInformation(const int state, const int state2);

};

c9.cc

#include "c9.h"
#include <vector>
#include <stdio.h>
#include <iterator>
// 把注册的观察者加入注册列表
void ConcreteSubject::mregister(Observer* observer) {
        this->observer_list.push_back(observer);
}

void ConcreteSubject::remove(Observer* observer) {
        for (std::vector<Observer*>::iterator it = observer_list.begin(); it != observer_list.end(); ++it) {
                if (*it == observer) {
                        this->observer_list.erase(it);
                        printf("an element was removed\n");
                }
        }
}
// 状态更新后此函数被调用，告知已注册的观察者自行更新到最新状态
void ConcreteSubject::notify() {
        for (std::vector<Observer*>::iterator it = this->observer_list.begin(); it != this->observer_list.end(); it++) {
                (*it)->doUpdate(this);
        }
}

int ConcreteSubject::getState() {
        return this->state;
}

int ConcreteSubject::getState2() {
        return this->state2;
}

void ConcreteSubject::setState(const int state) {
        this->state = state;
        notify();// 状态更新了，通知观察者
}

void ConcreteSubject::setState2(const int state) {
        this->state2 = state;
        notify();
}

ConcreteSubject::ConcreteSubject() {
        this->state = 0;
        this->state2 = 0;
}

void ConcreteObserver::doUpdate(ConcreteSubject* subject) {
        update(subject->getState());
}

void ConcreteObserver2::doUpdate(ConcreteSubject* subject) {
        update(subject->getState(), subject->getState2());
}

void ConcreteObserver::update(const int state) {
        displayInformation(state);
}

void ConcreteObserver2::update(const int state1, const int state2) {
        displayInformation(state1, state2);
}

void ConcreteObserver::displayInformation(const int state) {
        printf("ConcreteObserver update to state %d\n", state);
}

void ConcreteObserver2::displayInformation(const int state1, const int state2) {
        printf("ConcreteObserver2 update to state1 %d, state2 %d\n", state1, state2);
}

int main() {
        ConcreteSubject *cs = new ConcreteSubject;
        ConcreteObserver *co = new ConcreteObserver;
        ConcreteObserver2 *co2 = new ConcreteObserver2;
        cs->mregister(co);// 注册
        cs->mregister(co2);

        printf("state update:\n");
        cs->setState(10);// 更新状态

        printf("\n");

        printf("state2 update:\n");
        cs->setState2(20);// 更新状态
        return 0;
}

这样写的话，每当有其中一个状态更新，观察者都会执行一次更新而不管自己关注的状态是否真的需要更新， 这是不好的，有待改善。

以前看到别人写的代码好奇为啥看起来似乎有如此多的函数而每个函数却非常简短，现在算是明白了那是因为需要用这种方法来把某种结构搭建起来。