设计模式-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

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

设计模式-GOF行为模式(6-11)_第1张图片

类的实现上:

// 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

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

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

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

设计模式-GOF行为模式(6-11)_第2张图片

 

类的实现上:

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 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

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

设计模式-GOF行为模式(6-11)_第3张图片

类的实现:

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

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

设计模式-GOF行为模式(6-11)_第4张图片

 

类的实现:

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

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

设计模式-GOF行为模式(6-11)_第5张图片

 

类的实现:

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元的短信提醒费用。

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

设计模式-GOF行为模式(6-11)_第6张图片

 

类的实现:

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 m_array;

};

 

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


 



你可能感兴趣的:(C++,设计模式)