设计模式-GOF行为模式(6-11)

(Owed by: 春夜喜雨 http://blog.csdn.net/chunyexiyu)

行为型的模式有11种：

1.      责任链Chain of Responsibility

2.      命令Command

3.      解释器Interpreter

4.      迭代器Interator

5.      中介者Mediator

6.      备忘录Memento

7.      监听Observer

8.      状态State

9.      策略Strategy

10.  模板Template

11.  访问者Visitor

 

参考：https://yuerblog.cc/2017/01/17/gof-design-pattern-of-behavioral-pattern/

参考：http://www.cnblogs.com/gaochundong/p/design_pattern_mediator.html

参考：http://blog.csdn.net/caolaosanahnu/article/details/19647257

6.     备忘录Memento

在不破坏封装性的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态。用来恢复对象到保存的状态。

类的实现上：

// create memento, restore state from memento

class Originator

{

public:

   Memento* createMemento(){return new Memento(state());}

   void setMemento(Memento* m){setState(m->state());}

private:

   string state(){return m_state;}

   void setState(string s){m_state = s;}

   string m_state;

};

// memento

class Memento

{

proteced:

   string state(){return m_state;}

   void setState(string s){m_state = s;}

Memento(string s):m_state(s){};

friend class Originator;

private:

   string m_state;

};

// store memento

class CareTaker

{

public:

   CareTaker():m_pMemento(nullptr){}

   Memento* getMemento(){return m_pMemento;}

   void setMemento(Memento* m)

{

if (m_pMemento) delete m_pMemento;

m_pMemento = m;

}

private:

   Memento* m_pMemento;

};

 

 

7.     观察者Observer

建立对象与对象的依赖关系，一个对象发生改变时将自动通知其他对象，其它对象作出反应。

发生改变的对象称为：观察目标

被通知的对象称为：观察者

 

类的实现上：

class Subject;

class Observer

{

public:

   void update(Subject *);

};

class Subject

{

public:

   void attach(Observer* o)

   {

     m_list.push_back(o);

   };

   void detach(Observer* o)

   {

     m_list.remove(o);

   };

   void notify()

   {

     for (auto iter=m_list.begin(); iter != m_list.end(); ++iter)

        iter->update();

   };

virtual void getState() = 0;

   virtual void setState(int n) = 0;

private:

   std::list<Observer*> m_list;

};

class ConcreteSubject : public Subject

{

public:

   virtual void getState(){return m_nState;}

   virtual void setState(int n)

{

m_nState = n;

notify();

}

private:

   int m_nState;

};

class ConcreteObserver

{

public:

   void update(Subject* s)

   {

      m_nObstate = s->getState();

   };

private:

   m_nObState;

};

 

 

8.     状态State

状态模式主要是应对状态转换的条件比较复杂的情况，把状态的的判断逻辑转换到表示不同状态的一系列类当中，可以把复杂的状态判断简化。

类的实现：

class State

{

public:

   virtual void handle(Handle* p) = 0;

};

 

class ConcreteStateA : public State

{

public:

   virtual void handle(Handle* p)

   {

     p->changeState(new ConcreteStateB);

   }

};

class ConcreteStateB : public State

{

public:

   virtual void handle(Handle* p)

   {

     p->changeState(new ConcreteStateC);

   }

};

class ConcreteStateC : public State

{

public:

   virtual void handle(Handle* p)

   {

     p->changeState(new ConcreteStateA);

   }

};

 

 

class Context

{

public:

   Context(State* s):m_state(s){};

   void request()

{

   m_pState->handle(this);

}

   void changeState(State* s)

   {

      m_pState = s;

   }

private:

   State* m_pState;

};

 

 

9.     策略Strategy

策略模式实现对实现同种算法的封装，让这些算法之间互相可以方便的替代。

 

类的实现：

class Stragegy

{

public:

   virtual void algorithm() = 0;

};

 

class ConcreteAlgorithm1 : public Stragegy

{

public:

   virtual void algorithm()

   {

     …

   }

};

class ConcreteAlgorithm2 : public Stragegy

{

public:

   virtual void algorithm()

   {

     …

   }

};

 

class Context

{

public:

   void SetStragety(Stragegy* s){m_pStragegy = s;}

   void algorithm()

   {

      if (m_pStrategy) m_pStrategy->algorithm();

   }

private:

  Stragey* m_pStrategy;

};

 

 

10.     模板Template

模板模式的特点：基类提供了框架和一系列的方法，子类只需要重写特定的方法实现差异的部分即可。

 

类的实现：

class TemplateClass

{

public:

   final void temlateMethod()

   {

      …

operation1();

      …

      operation2();

      …

   };

   virtual void operation1();

   virtual void operation2();

};

 

class ConcreteClass1 : public TemplateClass

{

public:

   virtual void operation1()

   {

     …

   }

   virtual void operation2()

   {

     …

   }

 

};

 

11.     访问者Visitor

Visitor模式是把对元素的处理算法交给数据结构类，数据结构遍历自身元素，对每个元素调用该处理。

这样对于数据结构中元素的处理算法，随着不同的访问者改变而改变。

 

例如：收到指令，对每个银行账户扣款1元的短信提醒费用。

对于银行系统来说，账户的存储结构是不希望外部获取的，外部可以把处理交给存储结构类，有存储结构类来遍历元素，并调用处理。

 

类的实现：

class Visitor

{

public:

   virtual void visitElement(Element* pElement) = 0;

};

 

class Concrete Visitor: public Visitor

{

public:

   virtual void visitElement(Element* pElement)

   {

       // pElement do something;

   }

};

class Element

{

public:

   void accept(Visitor* pVisitor)

   {

      pVisitor->visitElement(this);

   };

}

class ObjectStructure

{

public:

void accpt(Visitor* pVisitor)

{

  for (iter =m_array.begin(); iter!=m_array.end(); iter++)

     iter->accept(pVisitor);

}

private:

    vector<Element> m_array;

};

 

 (Owed by: 春夜喜雨 http://blog.csdn.net/chunyexiyu)