[Boolan] C++第十三周 C++设计模式（三）

设计模式

状态变化 模式

1. Memento - 备忘录

Memento 模式的关键就是要在不破坏封装行的前提下，捕获并保存一个类的内部 状态，这样就可以利用该保存的状态实施恢复操作

#include <iostream>
#include <string>

using namespace std;

class Originator;
class Memento
{
    private:
    friend class Originator;
    typedef string State;

    Memento()
    :_sdt(""){}
    Memento(const State& sdt)
    :_sdt(sdt){}
    ~Memento(){}
    void SetState(const State& sdt)
    {
        _sdt = sdt;
    }

    State GetState(){
        return _sdt;
    }

    private:
    State _sdt;
};
class Originator
{
    public:
        typedef string State;
        Originator()
        :_sdt(""), _mt(NULL)
        {}

        Originator(const State& sdt)
            :_sdt(sdt), _mt(NULL)
        {}
        ~Originator(){}

        Memento* CreateMemento()
        {
            return new Memento(_sdt);
        }

        void SetMemento(Memento* men)
        {
            men = _mt;
        }
        void RestoreToMemento(Memento* mt)
        {
            this->_sdt = mt->GetState();
        }

        State GetState()
        {
            return _sdt;
        }

        void SetState(const State& sdt)
        {
            _sdt = sdt;
        }

        void PrintState()
        {
            cout << this->_sdt << "..." << endl;
        }

    private:
        State _sdt;
        Memento* _mt;
};

int main(int argc, char* argv[]) 
{
    Originator* o = new Originator();
    o->SetState("old"); //备忘前状态
    o->PrintState();

    Memento* m = o->CreateMemento();
    o->SetState("new"); //修改状态
    o->PrintState();
    o->RestoreToMemento(m);     //恢复状态
    o->PrintState();


    return 0;
}

2. State - 状态模式

允许一个对象在其内部状态改变时改变它的行为。从而使对象看起来似乎修改了其行为。

#include <iostream>

using namespace std;

class State;

class Context
{
    public:
        Context()
            :_state(NULL){ }
        Context(State* state){
            this->_state = state;
        }
        ~Context(){
        }

        void OperationInterface();
        void OperationChangeState();

    private:
        friend class State;
        bool ChangeState(State* state)
        {
            this->_state = state;
            return true;
        }
    private:
        State* _state;
};


class State
{
    public:
        State(){}
        virtual ~State(){}
        virtual void OperationInterface(Context*) {
            cout << "State::..." << endl;
        }
        virtual void OperationChangeState(Context*) = 0;
    protected:
        bool ChangeState(Context* con, State* st){
            con->ChangeState(st);
            return true;
        }
};

class ConcreteStateB;

class ConcreteStateA : public State
{
    public:
        ConcreteStateA(){}
        virtual ~ConcreteStateA(){}
        virtual void OperationInterface(Context*){
            cout << "ConcreteStateA::OperationInterface..." << endl;
        }
        virtual void OperationChangeState(Context* con);
};
class ConcreteStateB : public State
{
    public:
        ConcreteStateB(){}
        virtual ~ConcreteStateB(){}
        virtual void OperationInterface(Context*){
            cout << "ConcreteStateB::OperationInterface..." << endl;
        }
        virtual void OperationChangeState(Context* con){
            OperationInterface(con);
            this->ChangeState(con, new ConcreteStateA);
        }
};

void ConcreteStateA::OperationChangeState(Context* con){
    OperationInterface(con);
    this->ChangeState(con, new ConcreteStateB);
}
void Context::OperationInterface(){
    _state->OperationInterface(this);
}
void Context::OperationChangeState(){
    _state->OperationChangeState(this);
}


int main(int argc, char *argv[])
{
    State *st = new ConcreteStateA();
    Context* con = new Context(st);

    con->OperationChangeState();
    con->OperationChangeState();
    con->OperationChangeState();

    if(con != NULL)
        delete con;
    if(st != NULL)
        st = NULL;

    return 0;
}

数据结构式

1. Composite - 组合模式

将对象组合成树形结构以表示“部分-整体”的层次结构。 Composite使得用户对单个对象和组合对象的使用具有一致 性(稳定)。

#include <iostream>
#include <vector>

using namespace std;

class Component
{
    public:
        Component(){}
        ~Component(){}
    public:
        virtual void Operation() = 0;
        virtual void Add(const Component&) { }
        virtual void Remove(const Component&){ }
        virtual Component* GetChild(int) {
            return NULL;
        }
};

class Composite : public Component
{
    public:
        Composite(){}
        ~Composite(){}
        void Operation(){
            vector<Component*>::iterator comIter = comVec.begin();
            for(; comIter != comVec.end(); comIter++) {
                (*comIter)->Operation();
            }
        }
        void Add(Component* com){
            comVec.push_back(com);
        }
        void Remove(Component * com) {
            vector<Component*>::iterator iterVec = comVec.begin();
            for(; iterVec != comVec.end(); iterVec++) {
                if(*iterVec == com) {
                    comVec.erase(iterVec);
                    return;
                }
            }
        }
        Component* GetChild(int index) {
            return comVec[index];
        }
    private:
        vector<Component*> comVec;
};

class Leaf : public Component
{
    public:
        Leaf(){}
        ~Leaf(){}
        void Operation() {
            cout << "Leaf operation..." << endl;
        }
};




int main(int argc, char *argv[])
{
    Leaf * l = new Leaf();
    l->Operation();

    Composite* com = new Composite();
    com->Add(l);
    com->Operation();

    cout << "----------------" << endl;

    Component* ll = com->GetChild(0);
    ll->Operation();


    return 0;
}

2. Chain of Responsibility - 职责链

使多个对象都有机会处理请求，从而避免请求的发送者和接收者之间的耦合关系。将这些对象连成一条链，并沿着这条链传递请求，直到有一个对象处理它为止。

#include <iostream>

using namespace std;

class Handle
{
    public:
        virtual ~Handle(){
            delete _succ;
        }
        virtual void HandleRequest() = 0;
        void SetSuccessor(Handle* succ){
            _succ = succ;
        }
        Handle* GetSuccessor(){
            return _succ;
        }
    protected:
        Handle()
        :_succ(0){}
        Handle(Handle* succ)
        : _succ(succ){}
    private:
        Handle* _succ;
};

class ConcreteHandleA : public Handle
{
    public:
        ConcreteHandleA(){}
        ~ConcreteHandleA(){}
        ConcreteHandleA(Handle* succ)
        :Handle(succ){}
        void HandleRequest(){
            if(this->GetSuccessor() != 0) {
                cout << "ConcreteHandleA 我把处理权给后继节点..." << endl;
                this->GetSuccessor()->HandleRequest();
            } else{
                cout << "ConcreteHandleA 没有后继了，我必须自己处理..." << endl;
            }
        }
};
class ConcreteHandleB : public Handle
{
    public:
        ConcreteHandleB(){}
        ~ConcreteHandleB(){}
        ConcreteHandleB(Handle* succ)
        :Handle(succ){}
        void HandleRequest(){
            if(this->GetSuccessor() != 0) {
                cout << "ConcreteHandleB 我把处理权给后继节点..." << endl;
                this->GetSuccessor()->HandleRequest();
            } else{
                cout << "ConcreteHandleB 没有后继了，我必须自己处理..." << endl;
            }
        }
};

int main(int argc, char *argv[]) 
{
    Handle* h1 = new ConcreteHandleA();
    Handle* h2 = new ConcreteHandleB();

    h1->SetSuccessor(h2);
    h1->HandleRequest();

    return 0;
}

行为变化

2. Visitor - 访问器

表示一个作用于某对象结构中的各元素的操作。使得可以在不改变(稳定)各元素的类的前提下定义(扩展)作用于这些元素的新操作(变化)。

#include <iostream>

using namespace std;

class Element;

class Visitor
{
    public:
        virtual ~Visitor(){}
        virtual void VisitConcreteElementA(Element* elm) = 0;
        virtual void VisitConcreteElementB(Element* elm) = 0;
    protected:
        Visitor(){}
};

class ConcreteVisitorA : public Visitor
{
    public:
        ConcreteVisitorA(){}
        virtual ~ConcreteVisitorA(){}
        virtual void VisitConcreteElementA(Element* elm){
            cout << "I will visit ConcreteElementA..." << endl;
        }
        virtual void VisitConcreteElementB(Element* elm){ 
            cout << "I will visit ConcreteElementB..." << endl;
        }
};

class ConcreteVisitorB : public Visitor
{
    public:
        ConcreteVisitorB(){}
        virtual ~ConcreteVisitorB(){}
        virtual void VisitConcreteElementA(Element* elm){
            cout << "I will visit ConcreteElementA..." << endl;
        }
        virtual void VisitConcreteElementB(Element* elm){ 
            cout << "I will visit ConcreteElementB..." << endl;
        }
};

class Element
{
    public:
        virtual ~Element(){}
        virtual void Accept(Visitor* vis) = 0;
    protected:
        Element(){}
};

class ConcreteElementA : public Element
{
    public:
        ConcreteElementA(){}
        ~ConcreteElementA(){}

        void Accept(Visitor *vis) {
            vis->VisitConcreteElementA(this);
            cout << "visiting ConcreteElementA..." << endl;
        }
};
class ConcreteElementB : public Element
{
    public:
        ConcreteElementB(){}
        ~ConcreteElementB(){}

        void Accept(Visitor *vis) {
            cout << "visiting ConcreteElementB..." << endl;
            vis->VisitConcreteElementB(this);
        }
};


int main(int argc, char *argv[]) 
{
    Visitor* vis = new ConcreteVisitorA();
    Element* elm = new ConcreteElementA();
    elm->Accept(vis);

    return 0;
}

3. Interpreter - 解析器

给定一个语言，定义它的文法的一种表示，并定义一种解释器，这个解释器使用该表示来解释语言中的句子。

#include <iostream>
#include <string>

using namespace std;

class Context
{
    public:
        Context(){}
        ~Context(){}
};

class AbstractExpression
{
    public:
        virtual ~AbstractExpression(){}
        virtual void Interpret(const Context& c) {

        }
    protected:
        AbstractExpression(){}
};

class TerminalExpression : public AbstractExpression
{
    public:
        TerminalExpression(const string statement)
        : _statement(statement){}
        ~TerminalExpression(){}

        void Interpret(const Context& c) {
            cout << this->_statement << " TerminalExpression" << endl;
        }
    private:
        string _statement;
};

class NonterminalExpression : public AbstractExpression
{
    public:
        NonterminalExpression(AbstractExpression* expression, int times)
            : _expression(expression), _times(times)
        {
        }
        ~NonterminalExpression(){}

        void Interpret(const Context& c) {
            for(int i = 0; i < _times; i++) {
                this->_expression->Interpret(c);
            }
        }
    private:
        AbstractExpression* _expression;
        int _times;
};

int main(int argc, char *argv[])
{
    Context *c = new Context();

    AbstractExpression *te = new TerminalExpression("Hello");
    AbstractExpression* nte = new NonterminalExpression(te, 2);

    nte->Interpret(*c);

    return 0;
}