定义与结构
访问者模式，顾名思义使用了这个模式后就可以在不修改已有程序结构的前提下，通过
添加额外的“访问者”来完成对已有代码功能的提升。
定义为：表示一个作用于某对象结构中的各元
素的操作。它使你可以在不改变各元素的类的前提下定义作用于这些元素的新操作
1) 访问者角色（Visitor）：为该对象结构中具体元素角色声明一个访问操作接口。该操作
接口的名字和参数标识了发送访问请求给具体访问者的具体元素角色。这样访问者就可
以通过该元素角色的特定接口直接访问它。
2) 具体访问者角色（Concrete Visitor）：实现每个由访问者角色（Visitor）声明的操作。
3) 元素角色（Element）：定义一个Accept 操作，它以一个访问者为参数。
4) 具体元素角色（Concrete Element）：实现由元素角色提供的Accept 操作。
5) 对象结构角色（Object Structure）：这是使用访问者模式必备的角色。它要具备以下特
征：能枚举它的元素；可以提供一个高层的接口以允许该访问者访问它的元素；可以是
一个复合（组合模式）或是一个集合，如一个列表或一个无序集合。
class Visitor;
class Element
{
public:
virtual ~Element(){}
virtual void Accept(Visitor &rVisitor) = 0;
protected:
Element(){}
};
class ConcreateElementA
: public Element
{
public:
virtual ~ConcreateElementA() {}
virtual void Accept(Visitor &rVisitor);
};
class ConcreateElementB
: public Element
{
public:
virtual ~ConcreateElementB() {}
virtual void Accept(Visitor &rVisitor);
};
class Visitor
{
public:
virtual ~Visitor(){}
virtual void VisitConcreateElementA(ConcreateElementA *pConcreateElementA) = 0;
virtual void VisitConcreateElementB(ConcreateElementB *pConcreateElementB) = 0;
protected:
Visitor(){}
};
class ConcreateVisitorA
: public Visitor
{
public:
virtual ~ConcreateVisitorA(){}
virtual void VisitConcreateElementA(ConcreateElementA *pConcreateElementA);
virtual void VisitConcreateElementB(ConcreateElementB *pConcreateElementB);
};
class ConcreateVisitorB
: public Visitor
{
public:
virtual ~ConcreateVisitorB(){}
virtual void VisitConcreateElementA(ConcreateElementA *pConcreateElementA);
virtual void VisitConcreateElementB(ConcreateElementB *pConcreateElementB);
};
void ConcreateElementA::Accept(Visitor &rVisitor)
{
rVisitor.VisitConcreateElementA(this);
}
void ConcreateElementB::Accept(Visitor &rVisitor)
{
rVisitor.VisitConcreateElementB(this);
}
void ConcreateVisitorA::VisitConcreateElementA(ConcreateElementA *pConcreateElementA)
{
std::cout << "VisitConcreateElementA By ConcreateVisitorA\n";
}
void ConcreateVisitorA::VisitConcreateElementB(ConcreateElementB *pConcreateElementA)
{
std::cout << "VisitConcreateElementB By ConcreateVisitorA\n";
}
void ConcreateVisitorB::VisitConcreateElementA(ConcreateElementA *pConcreateElementA)
{
std::cout << "VisitConcreateElementA By ConcreateVisitorB\n";
}
void ConcreateVisitorB::VisitConcreateElementB(ConcreateElementB *pConcreateElementA)
{
std::cout << "VisitConcreateElementB By ConcreateVisitorB\n";
}
int main()
{
Visitor *pVisitorA = new ConcreateVisitorA();
Element *pElement = new ConcreateElementA();
pElement->Accept(*pVisitorA);
delete pElement;
delete pVisitorA;
return 0;
}
模板方法（Template Method）模式：定义一个操作中的算法的骨架，而将一些步骤延
迟到子类中。
组成
1) 抽象类（Abstract Class）：定义了一到多个的抽象方法，以供具体的子类来实现它们；
而且还要实现一个模板方法，来定义一个算法的骨架。该模板方法不仅调用前面的抽象
方法，也可以调用其他的操作，只要能完成自身的使命。
2) 具体类（Concrete Class）：实现父类中的抽象方法以完成算法中与特定子类相关的步骤。
// 抽象基类,定义算法的轮廓
class AbstractClass
{
public:
AbstractClass(){}
virtual ~AbstractClass(){}
// 这个函数中定义了算法的轮廓
void TemplateMethod();
protected:
// 纯虚函数,由派生类实现之
virtual void PrimitiveOperation1() = 0;
virtual void PrimitiveOperation2() = 0;
};
// 继承自AbstractClass,实现算法
class ConcreateClass
: public AbstractClass
{
public:
ConcreateClass(){}
virtual ~ConcreateClass(){}
protected:
virtual void PrimitiveOperation1();
virtual void PrimitiveOperation2();
};
#include "TemplateMethod.h"
#include <iostream>
void AbstractClass::TemplateMethod()
{
PrimitiveOperation1();
PrimitiveOperation2();
}
void ConcreateClass::PrimitiveOperation1()
{
std::cout << "PrimitiveOperation1 by ConcreateClass\n";
}
void ConcreateClass::PrimitiveOperation2()
{
std::cout << "PrimitiveOperation2 by ConcreateClass\n";
}
int main()
{
AbstractClass* pConcreateClass = new ConcreateClass;
pConcreateClass->TemplateMethod();
delete pConcreateClass;
system("pause");
return 0;
}
定义：允许一个对象在其内部状态改变时改变它的行为。
组成
1) 使用环境（Context）角色：客户程序是通过它来满足自己的需求。它定义了客户程序
需要的接口；并且维护一个具体状态角色的实例，这个实例来决定当前的状态。
2) 状态（State）角色：定义一个接口以封装与使用环境角色的一个特定状态相关的行为。
3) 具体状态（Concrete State）角色：实现状态角色定义的接口。
类图如下，结构非常简单也与策略模式非常相似。
class State;
class Context
{
public:
Context(State* pState);
~Context();
void Request();
void ChangeState(State *pState);
private:
State *m_pState;
};
class State
{
public:
virtual ~State(){}
virtual void Handle(Context* pContext) = 0;
};
class ConcreateStateA
: public State
{
public:
void Handle(Context* pContext);
};
class ConcreateStateB
: public State
{
public:
void Handle(Context* pContext);
};
Context::Context(State* pState)
: m_pState(pState)
{
}
Context::~Context()
{
delete m_pState;
m_pState = NULL;
}
void Context::Request()
{
if (NULL != m_pState)
{
m_pState->Handle(this);
}
}
void Context::ChangeState(State *pState)
{
if (NULL != m_pState)
{
delete m_pState;
m_pState = NULL;
}
m_pState = pState;
｝
void ConcreateStateA::Handle(Context* pContext)
{
std::cout << "Handle by ConcreateStateA\n";
if (NULL != pContext)
{
pContext->ChangeState(new ConcreateStateB());
}
}
void ConcreateStateB::Handle(Context* pContext)
{
std::cout << "Handle by ConcreateStateB\n";
if (NULL != pContext)
{
pContext->ChangeState(new ConcreateStateA());
}
}
int main()
{
State *pState = new ConcreateStateA();
Context *pContext = new Context(pState);
pContext->Request();
pContext->Request();
pContext->Request();
delete pContext;
return 0;
}
策略模式（Strategy）属于对象行为型设计模式，主要是定义一系列的算法，把这些算
法一个个封装成拥有共同接口的单独的类，并且使它们之间可以互换。
策略模式由三个角色组成：
1) 算法使用环境(Context)角色：算法被引用到这里和一些其它的与环境有关的操作一起
来完成任务。
2) 抽象策略(Strategy)角色：规定了所有具体策略角色所需的接口。在java 它通常由接口
或者抽象类来实现。
3) 具体策略(Concrete Strategy)角色：实现了抽象策略角色定义的接口。
class Strategy
{
public:
virtual ~Strategy(){}
virtual void AlgorithmInterface() = 0;
};
class ConcreateStrategyA
: public Strategy
{
public:
virtual ~ConcreateStrategyA(){}
virtual void AlgorithmInterface();
};
class Context
{
public:
Context(Strategy *pStrategy);
~Context();
void ContextInterface();
private:
Strategy* m_pStrategy;
};
Context::Context(Strategy *pStrategy)
: m_pStrategy(pStrategy)
{
}
Context::~Context()
{
delete m_pStrategy;
m_pStrategy = NULL;
}
void Context::ContextInterface()
{
if (NULL != m_pStrategy)
{
m_pStrategy->AlgorithmInterface();
}
}
void ConcreateStrategyA::AlgorithmInterface()
{
std::cout << "AlgorithmInterface Implemented by ConcreateStrategyA\n";
}
int main()
{
Strategy* pStrategy = new ConcreateStrategyA();
Context* pContext = new Context(pStrategy);
pContext->ContextInterface();
delete pContext;
return 0;
}
观察者（Observer）模式又名发布-订阅（Publish/Subscribe）模式。GOF 给观察者模
式如下定义：定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依
赖于它的对象都得到通知并被自动更新
1) 抽象目标角色（Subject）：目标角色知道它的观察者，可以有任意多个观察者观察同一
个目标。并且提供注册和删除观察者对象的接口。目标角色往往由抽象类或者接口来实
现。
2) 抽象观察者角色（Observer）：为那些在目标发生改变时需要获得通知的对象定义一个
更新接口。抽象观察者角色主要由抽象类或者接口来实现。
3) 具体目标角色（Concrete Subject）：将有关状态存入各个Concrete Observer 对象。当
它的状态发生改变时, 向它的各个观察者发出通知。
4) 具体观察者角色（Concrete Observer）：存储有关状态，这些状态应与目标的状态保持
一致。实现Observer 的更新接口以使自身状态与目标的状态保持一致。在本角色内也
可以维护一个指向Concrete Subject 对象的引用。
#include <list>
typedef int STATE;
class Observer;
// Subject抽象基类,只需要知道Observer基类的声明就可以了
class Subject
{
public:
Subject() : m_nSubjectState(-1){}
virtual ~Subject();
void Notify(); // 通知对象改变状态
void Attach(Observer *pObserver); // 新增对象
void Detach(Observer *pObserver); // 删除对象
// 虚函数,提供默认的实现,派生类可以自己实现来覆盖基类的实现
virtual void SetState(STATE nState); // 设置状态
virtual STATE GetState(); // 得到状态
protected:
STATE m_nSubjectState; // 模拟保存Subject状态的变量
std::list<Observer*> m_ListObserver; // 保存Observer指针的链表
};
// Observer抽象基类
class Observer
{
public:
Observer() : m_nObserverState(-1){}
virtual ~Observer(){}
// 纯虚函数,各个派生类可能有不同的实现
// 通知Observer状态发生了变化
virtual void Update(Subject* pSubject) = 0;
protected:
STATE m_nObserverState; // 模拟保存Observer状态的变量
};
// ConcreateSubject类,派生在Subject类
class ConcreateSubject
: public Subject
{
public:
ConcreateSubject() : Subject(){}
virtual ~ConcreateSubject(){}
// 派生类自己实现来覆盖基类的实现
virtual void SetState(STATE nState); // 设置状态
virtual STATE GetState(); // 得到状态
};
// ConcreateObserver类派生自Observer
class ConcreateObserver
: public Observer
{
public:
ConcreateObserver() : Observer(){}
virtual ~ConcreateObserver(){}
// 虚函数,实现基类提供的接口
virtual void Update(Subject* pSubject);
};
/* --------------------------------------------------------------------
| Subject类成员函数的实现
|
----------------------------------------------------------------------*/
void Subject::Attach(Observer *pObserver)
std::cout << "Attach an Observer\n";
m_ListObserver.push_back(pObserver);
}
void Subject::Detach(Observer *pObserver)
{
std::list<Observer*>::iterator iter;
iter = std::find(m_ListObserver.begin(), m_ListObserver.end(), pObserver);
if (m_ListObserver.end() != iter)
{
m_ListObserver.erase(iter);
}
std::cout << "Detach an Observer\n";
}
void Subject::Notify()
{
std::cout << "Notify Observers's State\n";
std::list<Observer*>::iterator iter1, iter2;
for (iter1 = m_ListObserver.begin(), iter2 = m_ListObserver.end();
iter1 != iter2;
++iter1)
{
(*iter1)->Update(this);
}
}
void Subject::SetState(STATE nState)
{
std::cout << "SetState By Subject\n";
m_nSubjectState = nState;
}
STATE Subject::GetState()
{
std::cout << "GetState By Subject\n";
return m_nSubjectState;
}
Subject::~Subject()
{
std::list<Observer*>::iterator iter1, iter2, temp;
for (iter1 = m_ListObserver.begin(), iter2 = m_ListObserver.end();
iter1 != iter2;
)
{
temp = iter1;
++iter1;
delete (*temp);
}
m_ListObserver.clear();
}
/* --------------------------------------------------------------------
| ConcreateSubject类成员函数的实现
|
----------------------------------------------------------------------*/
void ConcreateSubject::SetState(STATE nState)
{
std::cout << "SetState By ConcreateSubject\n";
m_nSubjectState = nState;
}
STATE ConcreateSubject::GetState()
{
std::cout << "GetState By ConcreateSubject\n";
return m_nSubjectState;
}
/* --------------------------------------------------------------------
| ConcreateObserver类成员函数的实现
|
----------------------------------------------------------------------*/
void ConcreateObserver::Update(Subject* pSubject)
{
if (NULL == pSubject)
return;
m_nObserverState = pSubject->GetState();
std::cout << "The ObeserverState is " << m_nObserverState << std::endl;
}
int main()
{
Observer *p1 = new ConcreateObserver;
Observer *p2 = new ConcreateObserver;
Subject* p = new ConcreateSubject;
p->Attach(p1);
p->Attach(p2);
p->SetState(4);
p->Notify();
p->Detach(p1);
p->SetState(10);
p->Notify();
delete p;
system("pause");
return 0;
}
备忘录械(MEmento)模式又称标记(Token)模式。定义：在不破坏封闭性的前提下，捕获一个对象的内部状态，并在该对象之 外保存这个状态。这样以后就可将该对象到原先保存的状态。
组成：
1. 备忘录（Memento）角色：备忘录角色存储“备忘发起角色”的内部状态。
2. 备忘发起（Originator）角色：“备忘发起角色”创建一个备忘录，用以记录当前时刻它的内部状态。在需要时使用备忘录恢复内部状态。
3. 备忘录管理者（Caretaker）角色：负责保存好备忘录。不能对备忘录的内容进行操作或检查。
typedef std::string State;
class Memento;
Class Originator{
Originator(const Sate& rState)
: m_State(rState)
{
}
Originator(){}
~Originator(){}
Memnto* CreateMemento(){return new Memento(m_State); }
Void SetMemento(Memento *pMemento){}
State GetState(){return m_State; }
Void SetState(const State& rState){ m_State = rState; }
Void RestoreState(Memento* pMemento){
if (NULL != pMemento)
{
m_State = pMemento->GetState();
}
}
Void PrintState()
{
std::cout << "State = " << m_State << std::endl;
}
};
Class Memento{
Private:
Friend class Originator;
Memento(const State& rState)
{
}
Void SetState(const State& rState)
: m_State(rState)
{
}
State GetState()
{
return m_State;
}
State m_State;
};
int main()
{
// 创建一个原发器
Originator* pOriginator = new Originator("old state");
pOriginator->PrintState();
// 创建一个备忘录存放这个原发器的状态
Memento *pMemento = pOriginator->CreateMemento();
// 更改原发器的状态
pOriginator->SetState("new state");
pOriginator->PrintState();
// 通过备忘录把原发器的状态还原到之前的状态
pOriginator->RestoreState(pMemento);
pOriginator->PrintState();
delete pOriginator;
delete pMemento;
return 0;
}
定义 用一个调停对象来封闭一系列的对象交互。
组成
1 抽象者调停者(Mediator)角色：调停者角色定义统一的接口用于各同事角色之间的通信。
2 具体调停者(Concrete Mediator)角色： 具体调停者角色通过协调各同事角色实现协作行为。为此它要知道并引用各个同事角色。
3 同事(Colleague)角色： 每一个同事角色都知道对应的具体调停者角色，而且与其他的同事通信的时候，一定要通过调停者角色协作。
Public Colleague{
Prvate:
Mediator mediator;
Public:
Colleague(Mediator mediator)
{
Mediator = mediator;
}
Mediator getMediator() const
{
Return mediator;
}
Virtual void action() = 0;
};
Class Landlord:public Colleague{
Void action()
{
Cout<<”进行房间资料交给中介操作，省略”;
}
};
Class Lodger:public Colleague{
Void action()
{
Cout<<”进行将租房需求交给中介等操作”;
}
};
Class Mediator{
Virtual void colleagueChanged(Colleague *colleague) = 0;
};
Class ConcreteMediator:public Mediator{
Private:
Landlord *landlord;
Lodger *lodger;
Void colleagueChanged(Colleague *colleague)
{
Landlord->action();
Lodger->action();
}
ConcreteMediator()
{
Landlord = new Landlord();
Lodger = new lodger();
}
~ ConcreteMediator()
{
Delete Landlord;
Delete Lodger;
}
};