大话设计模式
1 观察者模式（Observer）结构图
2 对观察者模式一些解释
概念：定义了一种一对多的依赖关系，让多个观察者多想同时监听某一个主题对象。这个主题对象在状态发生变化时，会通知所有观察者对象，使它们能够自动更新自己。【DP】。
Subject类，可译为主题或者抽象统治者，一般用一个类或者一个借口来实现。它把所有对观察者对象的引用保存在一个聚集里，每个主题都可以有任何数量的观察者。抽象主题提供一个接口，可以增加或者删除观察者对象。
class Subject
{
private:
vector<Observer> observers;
public:
//增加观察者
void Attatch(Observer observer)
{
observers.push_back(observer);
}
//减少观察者
void Detach(Observer observer)
{
observers.erase(observer);//形象的抽象出方法，实际上vector容器并不存在该该方法
}
//通知
void Notify()
{
for (auto &t : observers)
{
t.Update();
}
}
};
Observer类，抽象观察者，为所有的具体观察者定义一个接口，在得到主题的通知时更新自己。这个接口叫做更新接口。抽象观察者一般用一个抽象类或者一个接口实现。更新接口一般包含一个Update方法，这个方法叫做更新方法。
class Observer
{
public:
virtual void Update();
};
ConcreteSubject类，叫做具体主题或者具体统治者，将有关状态存入具体观察者对象；在具体主题的内部状态改变时，给所有登记过的观察者发出通知。具体主题角色通常用一个具体子类实现。（ 具体的被观察对象）
class ConcreteSubject :public Subject
{
private:
string subjectState;//具体被观察者状态
public:
string getSubjectState()
{
return subjectState;
}
void setSubjectState(string state)
{
subjectState = state;
}
};
ConcreteObserver类，具体观察者，实现抽象观察者角色所要求的更新接口，以便使本身的状态与主题的状态相协调。具体观察者角色可以保存一个指向具体主题对象的引用。具体观察者通常用一个具体子类来实现。
class ConcreteObserver :public Observer
{
private:
string name;
string observerState;
ConcreteSubject *subject;
public:
ConcreteObserver(ConcreteSubject *subject, string name)
{
this->subject = subject;
this->name = name;
}
void Update() override
{
observerState = subject->getSubjectState;
cout << "观察者" << name << "的状态是" << observerState << endl;
}
Subject *getSubject()
{
return subject;
}
void setSubject(ConcreteSubject *subject)
{
this->subject = subject;
}
};
客户端代码：
int main()
{
ConcreteSubject *s = new ConcreteSubject();
ConcreteObserver *o1 = new ConcreteObserver(s, "X");
ConcreteObserver *o2 = new ConcreteObserver(s, "Y");
ConcreteObserver *o3 = new ConcreteObserver(s, "Z");
s->setSubjectState("ABC");
s->Notify();
system("pause");
return 0;
}
运行结果：
观察者X的新状态是ABC
观察者Y的新状态是ABC
观察者Z的新状态是ABC
注意：其实Observer就是要通知的对象，而Subject就是观察者；ConcreteSubject中的subjectState是被观察对象。
3 C++代码实现
Subject.h
#ifndef SUBJECT_H
#define SUBJECT_H
#include <string>
#include <list>
class Observer;
//Subject，抽象通知者或者主题
class Subject
{
protected:
std::string SubjectState;
public:
virtual void Attach(Observer* observer)=0;
virtual void Detach(Observer* observer)=0;
virtual void Notify()=0;
std::string GetSubjectState();
void SetSubjectState(std::string state);
};
//ConcreteSubject，具体通知者或者具体主题。
class Boss:public Subject
{
private:
std::list<Observer*> observers;
std::string action;
public:
void Attach(Observer* observer);
void Detach(Observer* observer);
void Notify();
};
#endif
Subject.cpp
#include "Subject.h"
#include "Observer.h"
std::string Subject::GetSubjectState()
{
return SubjectState;
}
void Subject::SetSubjectState(std::string state)
{
this->SubjectState=state;
}
void Boss::Attach(Observer* observer)
{
observers.push_back(observer);
}
void Boss::Detach(Observer* observer)
{
std::list<Observer*>::iterator it;
for(it=observers.begin();it!=observers.end();it++)
{
if(*it==observer)
{
observers.erase(it);
break;
}
}
}
void Boss::Notify()
{
std::list<Observer*>::iterator it;
for(it=observers.begin();it!=observers.end();it++)
{
(**it).Update();
}
}
Observer.h
#ifndef OBSERVER_H
#define OBSERVER_H
#include <list>
#include <iostream>
#include <string>
#include "Subject.h"
//Observer,抽象观察者
class Observer
{
protected:
std::string name;
Subject* sub;
public:
Observer();
Observer(std::string name,Subject* sub);
virtual void Update();
bool operator==(const Observer&)const;
};
//ConcreteObserver,具体观察者，股票观察者
class StockObserver:public Observer
{
public:
StockObserver();
StockObserver(std::string name,Subject* sub);
void Update();
};
//ConcreteObserver，具体观察者，NBA观察者
class NBAObserver:public Observer
{
public:
NBAObserver();
NBAObserver(std::string name,Subject* sub);
void Update();
};
#endif
Observer.cpp
#include "Observer.h"
Observer::Observer(){}
Observer::Observer(std::string name,Subject* sub)
{
this->name=name;
this->sub=sub;
}
void Observer::Update()
{
std::cout<<"Observer.Update()"<<std::endl;
}
bool Observer::operator==(const Observer& observer)const
{
return (this->name==observer.name)&&(this->sub==observer.sub);
}
StockObserver::StockObserver(){}
StockObserver::StockObserver(std::string name,Subject* sub)
{
this->name=name;
this->sub=sub;
}
void StockObserver::Update()
{
std::cout<<sub->GetSubjectState()<<" "<<name<<" "<<"关闭股市行情，继续工作！"<<std::endl;
}
NBAObserver::NBAObserver(){}
NBAObserver::NBAObserver(std::string name,Subject* sub)
{
this->name=name;
this->sub=sub;
}
void NBAObserver::Update()
{
std::cout<<sub->GetSubjectState()<<" "<<name<<" "<<"关闭NBA直播，继续工作！"<<std::endl;
}
Client.cpp
#include "Observer.h"
#include <iostream>
#include <cstdlib>
//Client，客户端
void main()
{
//通知者
Subject* huhansan=new Boss();
//4个观察者实例
Observer* tongshi1=new StockObserver("魏关姹",huhansan);
Observer* tongshi2=new StockObserver("易管察",huhansan);
Observer* tongshi3=new NBAObserver("霍华德",huhansan);
Observer* tongshi4=new NBAObserver("林书豪",huhansan);
//将4个观察者都加入到通知者的通知队列中
huhansan->Attach(tongshi1);
huhansan->Attach(tongshi2);
huhansan->Attach(tongshi3);
huhansan->Attach(tongshi4);
//魏关姹没有被老板通知到，减去。
huhansan->Detach(tongshi1);
huhansan->SetSubjectState("我胡汉三回来了！");
//通知
huhansan->Notify();
delete huhansan;
delete tongshi1;
delete tongshi2;
delete tongshi3;
delete tongshi4;
std::cout<<""<<std::endl;
system("pause");
}
运行结果：
我胡汉三回来了！ 易管察 关闭股市行情，继续工作！
我胡汉三回来了！ 霍华德 关闭NBA直播，继续工作！
我胡汉三回来了！ 林书豪 关闭NBA直播，继续工作！
请按任意键继续. . .
![POJ 1284 Primitive Roots (欧拉函数&原根定理)[图]](data:image/gif;base64,R0lGODlhAQABAIAAAP///wAAACwAAAAAAQABAAACAkQBADs=)