C++面试题之 观察者模式

观察者模式是软件设计模式的一种。在此种模式中，一个目标对象管理所有相依于它的观察者对象，并且在它本身的状态改变时主动发出通知。这通常透过呼叫各观察者所提供的方法来实现。此种模式通常被用来实时事件处理系统。

1.模式定义

观察者模式(Observer Pattern)：定义对象间的一种一对多依赖关系，使得每当一个对象状态发生改变时，其相关依赖对象皆得到通知并被自动更新。观察者模式又叫做发布-订阅（Publish/Subscribe）模式、模型-视图（Model/View）模式、源-监听器（Source/Listener）模式或从属者（Dependents）模式。

2.模式结构

观察者模式包括一下角色：

Subject: 目标
ConcreteSubject: 具体目标
Observer: 观察者
ConcreteObserver: 具体观察者

3.代码分析

Observer.h

class Observer
{
public:
    Observer() {};
    virtual ~Observer() {};
    // 定义纯虚函数，规范接口
    virtual void update() = 0;
};

Subject.h

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

using namespace std;

class Subject
{
public:
    Subject() {};
    virtual ~Subject() {};
    void addObserver(Observer *observer);
    void deleteObserver(Observer *observer);
    void notifyObservers();
    virtual int getStatus() = 0;
    virtual void setStatus(int status) = 0;
private:
    vector<Observer*> m_observers;
};

Subject.cpp

#include "Subject.h"

void Subject::addObserver(Observer *observer)
{
    m_observers.push_back(observer);
}

void Subject::deleteObserver(Observer * observer)
{
    for (vector<Observer*>::iterator iter = m_observers.begin();
        iter != m_observers.end(); iter++)
    {
        if (*iter == observer)
        {
            m_observers.erase(iter);
            return;
        }
    }
}

void Subject::notifyObservers() {
    for (vector<Observer*>::iterator iter = m_observers.begin();
        iter != m_observers.end();
        iter++)
    {
        (*iter)->update();
    }
}

ConcreteObserver.h

#include <string>
#include "Observer.h"
#include "Subject.h"

using namespace std;

class ConcreteObserver : public Observer
{

public:
    ConcreteObserver(string name, Subject *subject) :m_observerName(name), m_subject(subject) {};
    ~ConcreteObserver() {};
    void update();

private:
    string m_observerName;
    Subject *m_subject;
};

ConcreteObserver.cpp

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

void ConcreteObserver::update()
{
    cout << "update observer[" << m_observerName << "] status:" << m_subject->getStatus() << endl;
}

ConcreteSubject.h

#include <string>
#include "Observer.h"
#include "Subject.h"

using namespace std;

class ConcreteSubject : public Subject
{

public:
    ConcreteSubject(string name) :m_subjectName(name) {};
    ~ConcreteSubject() {};

    void setStatus(int status);
    int getStatus();

private:
    string m_subjectName;
    int m_status = 0;
};

ConcreteSubject.cpp

#include <iostream>
#include "ConcreteSubject.h"

using namespace std;

void ConcreteSubject::setStatus(int status)
{
    m_status = status;
    cout << "setStatus subject[" << m_subjectName << "] status:" << status << endl;
}

int ConcreteSubject::getStatus()
{
    return m_status;
}

测试代码：

#include <iostream>
#include "Subject.h"
#include "Observer.h"
#include "ConcreteObserver.h"
#include "ConcreteSubject.h"

int main(int argc, char *argv[])
{
    Subject * subjectA = new ConcreteSubject("subjectA");
    Subject * subjectB = new ConcreteSubject("subjectB");

    Observer * observerA = new ConcreteObserver("observerA", subjectA);
    Observer * observerB = new ConcreteObserver("observerB", subjectB);

    subjectA->addObserver(observerA);
    subjectB->addObserver(observerB);

    subjectA->setStatus(1);
    subjectA->notifyObservers();

    subjectB->setStatus(2);
    subjectB->notifyObservers();

    cout << "--------------------" << endl;

    subjectA->addObserver(observerB);
    subjectA->setStatus(2);
    subjectA->notifyObservers();

    delete subjectA;
    delete subjectB;
    delete observerA;
    delete observerB;

    system("pause");

    return 0;
}

输出结果：

4.模式优点

观察者模式可以实现表示层和数据逻辑层的分离，并定义了稳定的消息更新传递机制，抽象了更新接口，使得可以有各种各样不同的表示层作为具体观察者角色。 
观察者模式在观察目标和观察者之间建立一个抽象的耦合。 
观察者模式支持广播通信。 
观察者模式符合“开闭原则”的要求。

5.模式缺点

如果一个观察目标对象有很多直接和间接的观察者的话，将所有的观察者都通知到会花费很多时间。 
如果在观察者和观察目标之间有循环依赖的话，观察目标会触发它们之间进行循环调用，可能导致系统崩溃。 
观察者模式没有相应的机制让观察者知道所观察的目标对象是怎么发生变化的，而仅仅只是知道观察目标发生了变化。

6.总结

观察者模式定义对象间的一种一对多依赖关系，使得每当一个对象状态发生改变时，其相关依赖对象皆得到通知并被自动更新。观察者模式又叫做发布-订阅模式、模型-视图模式、源-监听器模式或从属者模式。观察者模式是一种对象行为型模式。 
观察者模式包含四个角色：目标又称为主题，它是指被观察的对象；具体目标是目标类的子类，通常它包含有经常发生改变的数据，当它的状态发生改变时，向它的各个观察者发出通知；观察者将对观察目标的改变做出反应；在具体观察者中维护一个指向具体目标对象的引用，它存储具体观察者的有关状态，这些状态需要和具体目标的状态保持一致。 
观察者模式定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个目标对象，当这个目标对象的状态发生变化时，会通知所有观察者对象，使它们能够自动更新。 
观察者模式的主要优点在于可以实现表示层和数据逻辑层的分离，并在观察目标和观察者之间建立一个抽象的耦合，支持广播通信；其主要缺点在于如果一个观察目标对象有很多直接和间接的观察者的话，将所有的观察者都通知到会花费很多时间，而且如果在观察者和观察目标之间有循环依赖的话，观察目标会触发它们之间进行循环调用，可能导致系统崩溃。 
观察者模式适用情况包括：一个抽象模型有两个方面，其中一个方面依赖于另一个方面；一个对象的改变将导致其他一个或多个对象也发生改变，而不知道具体有多少对象将发生改变；一个对象必须通知其他对象，而并不知道这些对象是谁；需要在系统中创建一个触发链。