大話設計模式
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=)