观察者模式（C++实现）

（本博客旨在个人总结回顾）

1、详情：

观察者模式：定义对象间一种一对多的依赖关系，以便当该对象状态发生改变时，所有依赖它的对象都得到通知并自动刷新。

说明：

优点：

①观察者和被观察者是抽象耦合的。

②建立一套触发机制。

缺点：

①如果一个被观察者对象有很多的直接和间接的观察者的话，将所有的观察者都通知到会花费很多时间。

②如果在观察者和观察目标之间有循环依赖的话，观察目标会触发它们之间进行循环调用，可能导致系统崩溃。

③观察者模式没有相应的机制让观察者知道所观察的目标对象是怎么发生变化的，而仅仅只是知道观察目标发生了变化。

2.1、UML类图：

 

2.2、例子源码

stdafx.h

// stdafx.h : 标准系统包含文件的包含文件，
// 或是经常使用但不常更改的
// 特定于项目的包含文件
//

#pragma once

#include "targetver.h"

#include <stdio.h>
#include <tchar.h>

#include <iostream>
using namespace std;

// TODO:  在此处引用程序需要的其他头文件

Subject.h（主题接口类）

#pragma once
#include "Observer.h"
#include <list>
class Observer;

class Subject
{
public:
    Subject();
    virtual ~Subject();

public:
    virtual void Add(Observer* pObserver) = 0;
    virtual void Remove(Observer* pObserver) = 0;
    void Notify();

protected:
    std::list<Observer*> m_listObserver;
};

Subject.cpp

#include "stdafx.h"
#include "Subject.h"

Subject::Subject()
{
}

Subject::~Subject()
{
    for (std::list<Observer*>::iterator it = m_listObserver.begin(); it != m_listObserver.end(); it++)
    {
        delete (*it);
    }
    m_listObserver.clear();
}

void Subject::Notify()
{
    for (std::list<Observer*>::iterator it = m_listObserver.begin(); it != m_listObserver.end(); it++)
    {
        (*it)->Update();
    }
}

SubjectX.h(具体主题类)

#pragma once
#include "Subject.h"

class SubjectX :
    public Subject
{
public:
    SubjectX();
    ~SubjectX();

public:
    void Add(Observer* pObserver);
    void Remove(Observer* pObserver);
    void SetState(string strState);
    string GetState();

private:
    string m_strXState;
};

SubjectX.cpp

#include "stdafx.h"
#include "SubjectX.h"

SubjectX::SubjectX()
    : m_strXState("")
{
}

SubjectX::~SubjectX()
{
}

void SubjectX::Add(Observer* pObserver)
{
    m_listObserver.push_back(pObserver);
}

void SubjectX::Remove(Observer* pObserver)
{
    m_listObserver.remove(pObserver);
}

void SubjectX::SetState(string strState)
{
    m_strXState = strState;
}

std::string SubjectX::GetState()
{
    return m_strXState;
}

Observer.h(观察者接口类)

#pragma once

class Observer
{
public:
    Observer();
    virtual ~Observer();

public:
    virtual void Update() = 0;
};

Observer.cpp

#include "stdafx.h"
#include "Observer.h"

Observer::Observer()
{
}

Observer::~Observer()
{
}

ObserverX.h(具体观察者类)

#pragma once
#include "Observer.h"
#include "SubjectX.h"
class SubjectX;

class ObserverX :
    public Observer
{
public:
    ObserverX(SubjectX* pSubjectX, string strName);
    ~ObserverX();

public:
    void Update();

private:
    string m_strName;
    string m_strState;
    SubjectX* m_pSubjectX;
};

ObserverX.cpp

#include "stdafx.h"
#include "ObserverX.h"

ObserverX::ObserverX(SubjectX* pSubjectX, string strName)
    : m_strName(strName)
    , m_pSubjectX(pSubjectX)
    , m_strState("")
{
}

ObserverX::~ObserverX()
{
}

void ObserverX::Update()
{
    m_strState = m_pSubjectX->GetState();
    cout << "观察者<" << m_strName.c_str() << ">的新状态为：" << m_strState.c_str() << endl;
}

调用代码

ObserverPatternMemo.cpp

// ObserverPatternMemo.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include "ObserverX.h"
#include "SubjectX.h"

int _tmain(int argc, _TCHAR* argv[])
{
    SubjectX* pSubjectX = new SubjectX();

    pSubjectX->Add(new ObserverX(pSubjectX, "observer1"));
    pSubjectX->Add(new ObserverX(pSubjectX, "observer2"));
    pSubjectX->Add(new ObserverX(pSubjectX, "observer3"));
    pSubjectX->SetState("state11");
    pSubjectX->Notify();

    pSubjectX->SetState("state22");
    pSubjectX->Notify();

    system("pause");
    return 0;
}

2.3、运行结果：