状态模式--对象行为型模式

意图:允许一个对象在其内部状态改变时改变它的行为.对象看起来似乎修改了它的类.

适用性:

1 一个对象的行为取决于它的状态,并且它必须在运行时刻根据状态改变它的行为.

2 一个操作中含有庞大的多分支的条件语句,且这些分支依赖于该对象的状态.这个状态通常用一个或多个枚举常量表示,通常,有多个操作包含这一相同的条件结构.State模式将每一个条件分支放入一个独立的类中.这样可以根据对象自身情况将对象的状态作为一个对象,对象可以不依赖于其他对象而独立变化.

结构:

参与者:

Context(环境):

1定义客户感兴趣的接口. 2维护一个ConcreteState子类的实例，这个实例定义当前状态。

State（状态):定义一个接口以封装与Context的一个特定状态相关的行为。

ConcreteStateSubclasses（具体状态子类）：

每一子类实现一个与Context的一个状态相关的行为。

协作：

Context将于状态相关的请求委托给当前的ConcreteState对象处理。

Context可将自身作为一个参数传递给处理该请求的状态对象。这使得状态对象在必要时可访问Context

Context是客户使用的主要接口。客户可用状态对象来配置一个Context，一旦一个Context配置完毕，它的客户不再需要直接与状态对象打交道。

Context或ConcreteState子类都可决定哪个状态时另外哪一个的后继者，以及是在何种条件下进行状态转换。

效果：

1 它将于特定状态相关的行为局部化，并且将不同状态的行为分割开来。决定状态转移的逻辑不是在单块的if或switch语句中，而是分布在State子类之间。将每个状态转换和动作封装到一个类中，就把着眼点从执行状态提高到整个对象的状态。使代码结构话并使其意图更清晰。

2 使状态转换显示化：State保证Context不会发生内部状态不一致的情况，因为从Context的角度来看，状态转换是原子的。

3 State对象可被共享

实现：

1 谁定义状态转换：两者都可以，但若让State子类自身指定它们的后继状态以及何时进行转换，更灵活更合适。但是缺点是一个State子类至少拥有一个其他子类的信息，这就在各子类之间产生了实现依赖。

2 基于表的另一种方法 ：查找表的方式，使用表江输入映射到状态转换。对每一个状态，一张表将每一个可能的输入映射到一个后继状态。

表驱动的状态及与State模式的主要区别：State模式对于状态相关的行为进行建模，而表驱动的方式着重于定义状态转换。

3 创建和销毁State对象：何时创建何时销毁

4 使用动态继承

相关模式：

Flyweight：解释了何时以及怎样共享状态对象

状态对象通常是Singleton

书中代码：

//状态模式

#include <iostream>
using namespace std;

//复制了TCPConnection的状态改变接口，每一个TCPState操作
//都以一个TCPConnection实例作为一个参数，从而让TCPState可以访问其中的数据和改变状态的链接 
//以下类之间有相互依赖关系，所以需要注意前后顺序 
class TCPConnection;
class TCPState
{
public:
    virtual ~TCPState() 
    {
    }
    
    virtual void ActiveOpen(TCPConnection* t) 
    {
    }
    virtual void PassiveOpen(TCPConnection* t)
    {
    }
    virtual void Close(TCPConnection* t)
    {
    }
    virtual void Synchronize(TCPConnection* t) 
    {
    }
    virtual void Acknowlegde(TCPConnection* t) 
    {
    }
    virtual void Send(TCPConnection* t) 
    {
    }
protected:
    void ChangeState(TCPConnection* t, TCPState* s);
};

//类中所有的操作在完成与状态相关的工作后，这些操作都调用
//ChangeState操作来改变TCPConnection的状态。 
//TCPState的子类.都是单例模式 
class TCPEstablished : public TCPState
{
public:
    //static成员函数不能声明为虚函数，也不能声明为const 
    static TCPState* Instance()
    {
        if (_instance == 0)
            _instance = new TCPEstablished;
        else
            return _instance;
    }
    
    void Close(TCPConnection* t);
private:
    TCPEstablished() 
    {
    }
    static TCPState* _instance;
};
TCPState* TCPEstablished::_instance = 0;

//TCPState的子类.都是单例模式 
class TCPListen : public TCPState
{
public:
    //static成员函数不能声明为虚函数，也不能声明为const 
    static TCPState* Instance()
    {
        if (_instance == 0)
            _instance = new TCPListen;
        else
            return _instance;
    }
    
    void Send(TCPConnection* t)
    {
        cout << "Send" << endl;
        ChangeState(t, TCPEstablished::Instance());
    }
private:
    TCPListen() 
    {
    }
    static TCPState* _instance;
};
TCPState* TCPListen::_instance = 0;

void TCPEstablished::Close(TCPConnection* t)
{
    cout << "进行Close" << endl;
    ChangeState(t, TCPListen::Instance());
}

//TCPState的子类.都是单例模式 
class TCPClosed : public TCPState
{
public:
    //static成员函数不能声明为虚函数，也不能声明为const 
    static TCPState* Instance()
    {
        if (_instance == 0)
            _instance = new TCPClosed;
        else
            return _instance;
    }
    
    void ActiveOpen(TCPConnection* t)
    {
        cout << "进行ActiveOpen" << endl;
        ChangeState(t, TCPEstablished::Instance());
    }
    
    void PassiveOpen(TCPConnection* t)
    {
        cout << "进行PassiveOpen" << endl;
        ChangeState(t, TCPListen::Instance());
    }
private:
    TCPClosed() 
    {
    }
    static TCPState* _instance;
};
TCPState* TCPClosed::_instance = 0;

//提供了一个传送数据的接口并处理改变状态的请求 
class TCPConnection
{
public:
    //将State初始化为close()状态 
    TCPConnection() 
    {
        _state = TCPClosed::Instance();
    }
    
    void ActiveOpen() 
    {
        _state->ActiveOpen(this);
    }
    
    void PassiveOpen() 
    {
        _state->PassiveOpen(this);
    }
    void Close() 
    {
        _state->Close(this);
    }
    void Synchronize()
    {
        _state->Synchronize(this);
    }
    void Acknowlegde() 
    {
        _state->Acknowlegde(this);
    }
    void Send() 
    {
        _state->Send(this);
    }
    
protected:
    friend class TCPState;   //这样State类可以访问ChangeState，
                             //从而可以改变TCPConnection的状态 
    void ChangeState(TCPState* s)
    {
        _state = s;
    }
private:
    TCPState* _state;
}; 

void TCPState::ChangeState(TCPConnection* t, TCPState* s)
{
        t->ChangeState(s);
}