学习设计模式系列之二：状态模式

最近认真学习了一下设计模式中的一个比较简单的：状态模式，并用它设计了一个极其简单的“登录过程”的代码。

状态模式的优势：

1. 当系统中存在的状态很多（一般>=4），但状态的相互跳转并不复杂，即每个状态的出度较少（一般为1～3），这种情况下适合用状态模式；
2. 状态模式下，状态之间的跳转由状态对象自己负责，每个状态自己知道且只知道自己的跳转方法，这样设计起来简单，系统不需要同样管理状态之间的跳转。
3. 状态模式的优点在于能方便的进行状态之间的跳转，修改状态调整规则，以及扩展新的状态；

收获如下：

1. 要使用设计模式来设计系统的话，需要先画出UML图来，或者是类似的图，比如使用状态模式，就应该先画出类图（静态图）和状态图来；
2. 状态模式要先弄清楚有哪些状态，有哪些能产生状态转换的函数；
3. 极为简单的情况，可以用switch|if-else实现，但是复杂的情况，就应该使用状态模式，而且状态模式更加规范，易于维护和扩展；
4. 状态模式有多种实现方法，下面的这种方法是其中比较好的方法。

类图和状态图：

代码：

#include <stdlib.h>

inline void P(const char* str)
{
    printf("%s
", str);
}

// 用状态模式设计客户端登录过程
class Dialog;
class State
{
protected:
    Dialog* dlg;
public:
    State(Dialog* d): dlg(d){}

    // 定义能产生状态转换的方法
    virtual void click()=0;
    virtual void success()=0;
    virtual void close()=0;
};

class Start: public State
{
public:
    // 调用父类的构造函数
    Start(Dialog* d): State(d){}
    void click();
    void success(){};
    void close();
};
class Loading: public State
{
public:
    // 调用父类的构造函数
    Loading(Dialog* d): State(d){}
    void click();
    void success();
    void close();
};
class Main: public State
{
public:
    // 调用父类的构造函数
    Main(Dialog* d): State(d){}
    void click(){};
    void success(){};
    void close();
};
class Closed: public State
{
public:
    // 调用父类的构造函数
    Closed(Dialog* d): State(d){}
    void click(){};
    void success(){};
    void close(){};
};


class Dialog
{
private:
    State *state, *start, *loading, *main, *closed;
    bool is_active;
public:
    Dialog(): is_active(true)
    {
        start = new Start(this);
        loading = new Loading(this);
        main = new Main(this);
        closed = new Closed(this);
        state = start;
    }
    // 状态的set接口
    void setStart(){state = start;}
    void setLoading(){state = loading;}
    void setMain(){state = main;}
    void setClosed(){state = closed;}

    // 

    // 产生状态转换的函数
    void click(){state->click();}
    void success(){state->success();}
    void close(){state->close();}
    void print()
    {
        if(state == start)
            P("START");
        else if(state == loading)
            P("LOADING");
        else if(state == main)
            P("MAIN");
        else if(state == closed)
            P("CLOSED");
    }
};

// 实现函数接口
void Start::click()
{
    dlg->setLoading();
}
void Loading::click()
{
    dlg->setStart();
}
void Loading::success()
{
    dlg->setMain();
}
void Start::close()
{
    dlg->setClosed();
}
void Loading::close()
{
    dlg->setClosed();
}
void Main::close()
{
    dlg->setClosed();
}

int _tmain(int argc, _TCHAR* argv[])
{
    Dialog dlg;
    char ch;
    while(true)    // 消息循环
    {
        ch = getchar();
        switch(ch)
        {
        case 'c':    // 执行click函数
            dlg.click();
            dlg.print();
            break;
        case 'q':    // 执行close函数
            dlg.close();
            dlg.print();
            break;
        case 's':    // 执行success函数
            dlg.success();
            dlg.print();
            break;
        default:
            break;
        }
    }
    system("pause");
    return 0;
}

输出：

c
LOADING
c
START
c
LOADING
s
MAIN
q
CLOSED