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

 

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