C++设计模式之状态模式

最新推荐文章于 2021-03-30 17:47:55 发布
最新推荐文章于 2021-03-30 17:47:55 发布
阅读量993 收藏 1
点赞数
分类专栏： 设计模式

在阐述状态模式之前，先来看一个例子。一个银行取款问题: 如果账户余额大于0，则正常取款；如果 余额在-2000和0之间，则透支取款；如果余额小于-2000，则账户处于冻结状态，无法进行取款操作。

    实现代码如下:

[cpp] view plain copy print ?
  1. //银行账户  
  2. class Account  
  3. {  
  4. private:  
  5.     //余额  
  6.     int m_nBalance;       
  7. public:  
  8.     //取款操作  
  9.     void WithDraw()  
  10.     {  
  11.         if( m_nBalance > 0 )                   
  12.         {  
  13.             cout << "正常取款状态" << endl;  
  14.         }  
  15.         else if( m_nBalance > -2000 )              
  16.         {  
  17.             cout << "透支状态" << endl;  
  18.         }  
  19.         else                                      
  20.         {  
  21.             cout << "冻结状态" << endl;  
  22.         }  
  23.     }  
  24. };  
//银行账户
class Account
{
private:
	//余额
	int m_nBalance;		
public:
	//取款操作
	void WithDraw()
	{
		if( m_nBalance > 0 )					
		{
			cout << "正常取款状态" << endl;
		}
		else if( m_nBalance > -2000 )			
		{
			cout << "透支状态" << endl;
		}
		else									
		{
			cout << "冻结状态" << endl;
		}
	}
};
    执行取款这一操作，存在正常状态、透支状态、冻结状态三种状态。不同状态下，取款操作对应有不同的行为。如果需要添加一种新的状态，如:账户余额小于-10000，直接注销此账户，并且接受法院的传票，得修改上述代码。执行某一个操作，需要判断这一操作是在哪一个状态下执行的，判断该状态下是否具有该方法，以及特定状态下如何实现该方法，将导致大量的if...else条件判断，新增新的状态，得修改源代码，违背"开放封闭原则"。

    因此有必要对这些状态进行封装，将状态的行为封装到具体的状态中。为了解决这些问题，我们可以使用状态模式，在状态模式中，我们将对象在每一个状态下的行为和状态转移语句封装在一个个状态类中，通过这些状态类来分散冗长的条件转移语句，让系统具有更好的灵活性和可扩展性。

1、状态模式概述

    状态模式用于解决系统中复杂对象的状态转换以及不同状态下行为的封装问题。当系统中某个对象存在多个状态，这些状态之间可以进行转换，而且对象在不同状态下行为不相同时可以使用状态模式。状态模式将一个对象的状态从该对象中分离出来，封装到专门的状态类中，使得对象状态可以灵活变化，对于客户端而言，无须关心对象状态的转换以及对象所处的当前状态，无论对于何种状态的对象，客户端都可以一致处理。

状态模式(State Pattern)：允许一个对象在其内部状态改变时改变它的行为，对象看起来似乎修改了它的类。其别名为状态对象(Objects for States)，状态模式是一种对象行为型模式。

       在状态模式中引入了抽象状态类和具体状态类，它们是状态模式的核心。

状态模式结构图

    在状态模式结构图中包含如下几个角色：

    Context（环境类）：环境类又称为上下文类，它是拥有多种状态的对象。由于环境类的状态存在多样性且在不同状态下对象的行为有所不同，因此将状态独立出去形成单独的状态类。在环境类中维护一个抽象状态类State的实例，这个实例定义当前状态，在具体实现时，它是一个State子类的对象。

    State（抽象状态类）：它用于定义一个接口以封装与环境类的一个特定状态相关的行为，在抽象状态类中声明了各种不同状态对应的方法，而在其子类中实现类这些方法，由于不同状态下对象的行为可能不同，因此在不同子类中方法的实现可能存在不同，相同的方法可以写在抽象状态类中。

    ConcreteState（具体状态类）：它是抽象状态类的子类，每一个子类实现一个与环境类的一个状态相关的行为，每一个具体状态类对应环境的一个具体状态，不同的具体状态类其行为有所不同。

    在状态模式中，我们将对象在不同状态下的行为封装到不同的状态类中，为了让系统具有更好的灵活性和可扩展性，同时对各状态下的共有行为进行封装，我们需要对状态进行抽象，引入了抽象状态类角色，其典型代码如下所示：

[cpp] view plain copy print ?
  1. class State  
  2. {  
  3. public:  
  4.     //声明抽象业务方法，不同的具体状态类可以不同的实现  
  5.     void handle();  
  6. };  
class State
{
public:
    //声明抽象业务方法，不同的具体状态类可以不同的实现
    void handle();
};

    在抽象状态类的子类即具体状态类中实现了在抽象状态类中声明的业务方法，不同的具体状态类可以提供完全不同的方法实现，在实际使用时，在一个状态类中可能包含多个业务方法，如果在具体状态类中某些业务方法的实现完全相同，可以将这些方法移至抽象状态类，实现代码的复用，典型的具体状态类代码如下所示

[cpp] view plain copy print ?
  1. class ConcreteState : public State  
  2. {  
  3. public:  
  4.     void handle()  
  5.     {  
  6.     //方法具体实现代码  
  7.     }  
  8. }  
class ConcreteState : public State
{
public:
    void handle()
    {
	//方法具体实现代码
    }
}
    环境类维持一个对抽象状态类的引用，通过setState()方法可以向环境类注入不同的状态对象，再在环境类的业务方法中调用状态对象的方法，典型代码如下所示。
[cpp] view plain copy print ?
  1. class Context  
  2. {  
  3. private:  
  4.     //维持一个对抽象状态对象的引用  
  5.         State state;   
  6.       
  7.     //其他属性值，该属性值的变化可能会导致对象状态发生变化  
  8.     int value;   
  9. public:  
  10.         //设置状态对象  
  11.     void setState(State state)  
  12.     {  
  13.         this.state = state;  
  14.     }  
  15.   
  16.     //调用状态对象的业务方法  
  17.     void request()  
  18.     {  
  19.         state.handle();   
  20.             //其他代码  
  21.     }  
  22. }  
class Context
{
private:
	//维持一个对抽象状态对象的引用
        State state; 
	
	//其他属性值，该属性值的变化可能会导致对象状态发生变化
	int value; 
public:
        //设置状态对象
	void setState(State state)
	{
	    this.state = state;
	}

	//调用状态对象的业务方法
	void request()
	{
	    state.handle(); 
            //其他代码
	}
}


    环境类实际上是真正拥有状态的对象，我们只是将环境类中与状态有关的代码提取出来封装到专门的状态类中，环境类Context与抽象状态类State之间是一种关联关系。和策略模式相似，策略模式封装的是一个个具体策略，环境类Context引用一个具体的策略；而状态模式封装的是一个个具体的状态，环境类Context也维持了一个对具体状态的引用。两者都是通过组合的方式，实现软件复用的功能。

2、智能空调的设计与实现

某软件公司将开发一套智能空调系统： 系统检测到温度处于20---30度之间，则切换到常温状态；温度处于30---45度，则切换到制冷状态； 温度小于20度，则切换到制热状态。请使用状态模式对此系统进行设计。

    从需求中可以看出，空调可以处于三种状态: 制热状态、常温状态、制冷状态。每种状态下都存在三种行为:保持常温、制冷、制热。

    空调抽象状态实现代码如下:

[cpp] view plain copy print ? 在CODE上查看代码片 派生到我的代码片
  1. //空调抽象状态类  
  2. class AirConditionerState  
  3. {  
  4. public:   
  5.     //保持常温  
  6.     virtual void KeepNormalTemperature(AirConditioner * pAirConditioner) = 0;  
  7.   
  8.     //制冷  
  9.     virtual void refrigerate(AirConditioner * pAirConditioner) = 0;  
  10.       
  11.     //制热  
  12.     virtual void Heat(AirConditioner * pAirConditioner) = 0;  
  13. };  
//空调抽象状态类
class AirConditionerState
{
public:	
	//保持常温
	virtual void KeepNormalTemperature(AirConditioner * pAirConditioner) = 0;

	//制冷
	virtual void refrigerate(AirConditioner * pAirConditioner) = 0;
	
	//制热
	virtual void Heat(AirConditioner * pAirConditioner) = 0;
};

    三种具体状态类声明如下:

[cpp] view plain copy print ? 在CODE上查看代码片 派生到我的代码片
  1. //常温状态  
  2. class NormalTemperatureState : public AirConditionerState  
  3. {  
  4. public:   
  5.     //保持常温  
  6.     void KeepNormalTemperature(AirConditioner * pAirConditioner);  
  7.   
  8.     //制冷  
  9.     void refrigerate(AirConditioner * pAirConditioner);  
  10.       
  11.     //制热  
  12.     void Heat(AirConditioner * pAirConditioner);  
  13. };  
  14.   
  15.   
  16.   
  17. //制冷状态  
  18. class RefrigerateState : public AirConditionerState  
  19. {  
  20. public:   
  21.     //保持常温  
  22.     void KeepNormalTemperature(AirConditioner * pAirConditioner);  
  23.       
  24.       
  25.     //制冷  
  26.     void refrigerate(AirConditioner * pAirConditioner);  
  27.       
  28.     //制热  
  29.     void Heat(AirConditioner * pAirConditioner);  
  30. };  
  31.   
  32.   
  33.   
  34.   
  35. //制热状态  
  36. class HeatState : public AirConditionerState  
  37. {  
  38. public:   
  39.     //保持常温  
  40.     void KeepNormalTemperature(AirConditioner * pAirConditioner);  
  41.       
  42.     //制冷  
  43.     void refrigerate(AirConditioner * pAirConditioner);  
  44.       
  45.     //制热  
  46.     void Heat(AirConditioner * pAirConditioner);  
  47. };  
//常温状态
class NormalTemperatureState : public AirConditionerState
{
public:	
	//保持常温
	void KeepNormalTemperature(AirConditioner * pAirConditioner);

	//制冷
	void refrigerate(AirConditioner * pAirConditioner);
	
	//制热
	void Heat(AirConditioner * pAirConditioner);
};



//制冷状态
class RefrigerateState : public AirConditionerState
{
public:	
	//保持常温
	void KeepNormalTemperature(AirConditioner * pAirConditioner);
	
	
	//制冷
	void refrigerate(AirConditioner * pAirConditioner);
	
	//制热
	void Heat(AirConditioner * pAirConditioner);
};




//制热状态
class HeatState : public AirConditionerState
{
public:	
	//保持常温
	void KeepNormalTemperature(AirConditioner * pAirConditioner);
	
	//制冷
	void refrigerate(AirConditioner * pAirConditioner);
	
	//制热
	void Heat(AirConditioner * pAirConditioner);
};

    每种状态下都存在保持常温、制冷、制热方法。这些方法带有一个AirConditioner类参数，方法内部使用这个参数回调空调的温度值，根据这个温度值，用于判断该方法如何实现，以及如何切换到其他状态。三种状态实现代码如下:

[cpp] view plain copy print ? 在CODE上查看代码片 派生到我的代码片
  1. /******************************正常温度状态******************************************/  
  2.   
  3. //保持常温  
  4. void NormalTemperatureState::KeepNormalTemperature(AirConditioner * pAirConditioner)  
  5. {  
  6.   
  7.     int nTemperature = pAirConditioner->GetTemperature();  
  8.   
  9.     if( nTemperature > 20 && nTemperature <= 30 )  
  10.     {  
  11.         cout << "已经是常温状态，不能调节为常温" << endl;  
  12.     }  
  13. }  
  14.   
  15.   
  16.   
  17. //制冷  
  18. void NormalTemperatureState::refrigerate(AirConditioner * pAirConditioner)  
  19. {  
  20.     int nTemperature = pAirConditioner->GetTemperature();  
  21.       
  22.     if( nTemperature > 30 && nTemperature <= 45 )  
  23.     {  
  24.         pAirConditioner->SetAirConditionerState(pAirConditioner->GetRefrigerateState());  
  25.   
  26.         cout << "切换到制冷状态" << endl;  
  27.     }  
  28. }  
  29.       
  30.   
  31.   
  32. //制热  
  33. void NormalTemperatureState::Heat(AirConditioner * pAirConditioner)  
  34. {  
  35.     int nTemperature = pAirConditioner->GetTemperature();  
  36.       
  37.     if( nTemperature <= 20 )  
  38.     {  
  39.         pAirConditioner->SetAirConditionerState(pAirConditioner->GetHeatState());  
  40.   
  41.         cout << "切换到制热状态" << endl;  
  42.     }  
  43. }  
  44.   
  45.   
  46.   
  47. /******************************制冷状态******************************************/  
  48.   
  49. //保持常温  
  50. void RefrigerateState::KeepNormalTemperature(AirConditioner * pAirConditioner)  
  51. {  
  52.     int nTemperature = pAirConditioner->GetTemperature();  
  53.       
  54.     if( nTemperature > 20 && nTemperature <= 30 )  
  55.     {  
  56.         pAirConditioner->SetAirConditionerState(pAirConditioner->GetNormalTemperatureState());  
  57.   
  58.         cout << "切换到常温状态" << endl;  
  59.     }  
  60. }  
  61.       
  62.   
  63.   
  64. //制冷  
  65. void RefrigerateState::refrigerate(AirConditioner * pAirConditioner)  
  66. {  
  67.     int nTemperature = pAirConditioner->GetTemperature();  
  68.       
  69.     if( nTemperature > 30 && nTemperature <= 45 )  
  70.     {  
  71.         cout << "已经是制冷状态，不能调节为制冷状态" << endl;  
  72.     }  
  73. }  
  74.       
  75.   
  76.   
  77. //制热  
  78. void RefrigerateState::Heat(AirConditioner * pAirConditioner)  
  79. {  
  80.     int nTemperature = pAirConditioner->GetTemperature();  
  81.       
  82.     if( nTemperature <= 20 )  
  83.     {  
  84.         pAirConditioner->SetAirConditionerState(pAirConditioner->GetHeatState());  
  85.   
  86.         cout << "切换到制热状态" << endl;  
  87.     }  
  88. }  
  89.   
  90.   
  91.   
  92. /******************************制热状态******************************************/  
  93.   
  94.   
  95. //保持常温  
  96. void HeatState::KeepNormalTemperature(AirConditioner * pAirConditioner)  
  97. {  
  98.     int nTemperature = pAirConditioner->GetTemperature();  
  99.       
  100.     if( nTemperature > 20 && nTemperature <= 30 )  
  101.     {  
  102.         pAirConditioner->SetAirConditionerState(pAirConditioner->GetNormalTemperatureState());  
  103.   
  104.         cout << "切换到常温状态" << endl;  
  105.     }  
  106. }  
  107.       
  108.       
  109.   
  110. //制冷  
  111. void HeatState::refrigerate(AirConditioner * pAirConditioner)  
  112. {  
  113.     int nTemperature = pAirConditioner->GetTemperature();  
  114.       
  115.     if( nTemperature > 30 && nTemperature <= 45 )  
  116.     {  
  117.         pAirConditioner->SetAirConditionerState(pAirConditioner->GetRefrigerateState());  
  118.   
  119.         cout << "切换到制冷状态" << endl;  
  120.     }  
  121. }  
  122.   
  123.   
  124.       
  125. //制热  
  126. void HeatState::Heat(AirConditioner * pAirConditioner)  
  127. {  
  128.     int nTemperature = pAirConditioner->GetTemperature();  
  129.       
  130.     if( nTemperature <= 20 )  
  131.     {  
  132.         cout << "已经是制热状态，不能调节为制热状态" << endl;  
  133.     }  
  134. }  
/******************************正常温度状态******************************************/

//保持常温
void NormalTemperatureState::KeepNormalTemperature(AirConditioner * pAirConditioner)
{

	int nTemperature = pAirConditioner->GetTemperature();

	if( nTemperature > 20 && nTemperature <= 30 )
	{
		cout << "已经是常温状态，不能调节为常温" << endl;
	}
}



//制冷
void NormalTemperatureState::refrigerate(AirConditioner * pAirConditioner)
{
	int nTemperature = pAirConditioner->GetTemperature();
	
	if( nTemperature > 30 && nTemperature <= 45 )
	{
		pAirConditioner->SetAirConditionerState(pAirConditioner->GetRefrigerateState());

		cout << "切换到制冷状态" << endl;
	}
}
	


//制热
void NormalTemperatureState::Heat(AirConditioner * pAirConditioner)
{
	int nTemperature = pAirConditioner->GetTemperature();
	
	if( nTemperature <= 20 )
	{
		pAirConditioner->SetAirConditionerState(pAirConditioner->GetHeatState());

		cout << "切换到制热状态" << endl;
	}
}



/******************************制冷状态******************************************/

//保持常温
void RefrigerateState::KeepNormalTemperature(AirConditioner * pAirConditioner)
{
	int nTemperature = pAirConditioner->GetTemperature();
	
	if( nTemperature > 20 && nTemperature <= 30 )
	{
		pAirConditioner->SetAirConditionerState(pAirConditioner->GetNormalTemperatureState());

		cout << "切换到常温状态" << endl;
	}
}
	


//制冷
void RefrigerateState::refrigerate(AirConditioner * pAirConditioner)
{
	int nTemperature = pAirConditioner->GetTemperature();
	
	if( nTemperature > 30 && nTemperature <= 45 )
	{
		cout << "已经是制冷状态，不能调节为制冷状态" << endl;
	}
}
	


//制热
void RefrigerateState::Heat(AirConditioner * pAirConditioner)
{
	int nTemperature = pAirConditioner->GetTemperature();
	
	if( nTemperature <= 20 )
	{
		pAirConditioner->SetAirConditionerState(pAirConditioner->GetHeatState());

		cout << "切换到制热状态" << endl;
	}
}



/******************************制热状态******************************************/


//保持常温
void HeatState::KeepNormalTemperature(AirConditioner * pAirConditioner)
{
	int nTemperature = pAirConditioner->GetTemperature();
	
	if( nTemperature > 20 && nTemperature <= 30 )
	{
		pAirConditioner->SetAirConditionerState(pAirConditioner->GetNormalTemperatureState());

		cout << "切换到常温状态" << endl;
	}
}
	
	

//制冷
void HeatState::refrigerate(AirConditioner * pAirConditioner)
{
	int nTemperature = pAirConditioner->GetTemperature();
	
	if( nTemperature > 30 && nTemperature <= 45 )
	{
		pAirConditioner->SetAirConditionerState(pAirConditioner->GetRefrigerateState());

		cout << "切换到制冷状态" << endl;
	}
}


	
//制热
void HeatState::Heat(AirConditioner * pAirConditioner)
{
	int nTemperature = pAirConditioner->GetTemperature();
	
	if( nTemperature <= 20 )
	{
		cout << "已经是制热状态，不能调节为制热状态" << endl;
	}
}

    空调类，也就是环境类Contex,维护了一个状态的引用，实现的时候将调用状态对象的方法。声明代码如下:

[cpp] view plain copy print ? 在CODE上查看代码片 派生到我的代码片
  1. //空调类  
  2. class AirConditioner  
  3. {  
  4. private:  
  5.     //空调名称  
  6.     string m_strAirName;  
  7.   
  8.     //空调当前温度  
  9.     int m_nTemperature;  
  10.       
  11.     //常温状态  
  12.     AirConditionerState * m_pNormalTemperatureState;  
  13.       
  14.     //制冷状态  
  15.     AirConditionerState * m_pRefrigerateState;  
  16.   
  17.     //制热状态  
  18.     AirConditionerState * m_pHeatState;  
  19.   
  20.     //当前温度状态  
  21.     AirConditionerState * m_pCurState;  
  22. public:  
  23.     //构造函数  
  24.     AirConditioner(string strAirName, int nTemperature);  
  25.   
  26.     //虚构函数  
  27.     ~AirConditioner();  
  28.       
  29.     //调节温度  
  30.     void SetTemperature(int nTemperature);  
  31.   
  32.     //获取温度  
  33.     int GetTemperature();  
  34.   
  35.     //设置空调状态  
  36.     void SetAirConditionerState(AirConditionerState * pAirConditionerState);  
  37.   
  38.       
  39.     //获取常温状态  
  40.     AirConditionerState * GetNormalTemperatureState();  
  41.   
  42.     //获取制冷状态  
  43.     AirConditionerState * GetRefrigerateState();  
  44.   
  45.     //获取制热状态  
  46.     AirConditionerState * GetHeatState();  
  47.   
  48.   
  49.     //保持常温  
  50.     void KeepNormalTemperature();  
  51.   
  52.     //制冷  
  53.     void refrigerate();  
  54.   
  55.     //制热  
  56.     void Heat();  
  57.       
  58. };  
//空调类
class AirConditioner
{
private:
	//空调名称
	string m_strAirName;

	//空调当前温度
	int m_nTemperature;
	
	//常温状态
	AirConditionerState * m_pNormalTemperatureState;
	
	//制冷状态
	AirConditionerState * m_pRefrigerateState;

	//制热状态
	AirConditionerState * m_pHeatState;

	//当前温度状态
	AirConditionerState * m_pCurState;
public:
	//构造函数
	AirConditioner(string strAirName, int nTemperature);

	//虚构函数
	~AirConditioner();
	
	//调节温度
	void SetTemperature(int nTemperature);

	//获取温度
	int GetTemperature();

	//设置空调状态
	void SetAirConditionerState(AirConditionerState * pAirConditionerState);

	
	//获取常温状态
	AirConditionerState * GetNormalTemperatureState();

	//获取制冷状态
	AirConditionerState * GetRefrigerateState();

	//获取制热状态
	AirConditionerState * GetHeatState();


	//保持常温
	void KeepNormalTemperature();

	//制冷
	void refrigerate();

	//制热
	void Heat();
	
};

    空调类实现代码如下：

[cpp] view plain copy print ? 在CODE上查看代码片 派生到我的代码片
  1. //构造函数  
  2. AirConditioner::AirConditioner(string strAirName, int nTemperature)  
  3. {  
  4.     m_strAirName = strAirName;  
  5.     m_nTemperature = nTemperature;  
  6.   
  7.     m_pNormalTemperatureState = new NormalTemperatureState();  
  8.     m_pRefrigerateState = new RefrigerateState();  
  9.     m_pHeatState = new HeatState();  
  10.   
  11.     m_pCurState = m_pNormalTemperatureState;  
  12. }  
  13.   
  14.   
  15.   
  16. //虚构函数  
  17. AirConditioner::~AirConditioner()  
  18. {  
  19.     delete m_pNormalTemperatureState;  
  20.     m_pNormalTemperatureState = NULL;  
  21.   
  22.     delete m_pRefrigerateState;  
  23.     m_pRefrigerateState = NULL;  
  24.   
  25.     delete m_pHeatState;  
  26.     m_pHeatState = NULL;  
  27. }  
  28.       
  29.   
  30.   
  31.   
  32. //调节温度  
  33. void AirConditioner::SetTemperature(int nTemperature)  
  34. {  
  35.     m_nTemperature = nTemperature;  
  36. }  
  37.   
  38.   
  39.   
  40. //获取温度  
  41. int AirConditioner::GetTemperature()  
  42. {  
  43.     return m_nTemperature;  
  44. }  
  45.   
  46.   
  47.   
  48. //设置空调状态  
  49. void AirConditioner::SetAirConditionerState(AirConditionerState * pAirConditionerState)  
  50. {  
  51.     m_pCurState = pAirConditionerState;  
  52. }  
  53.   
  54.   
  55.   
  56.   
  57.   
  58. //获取常温状态  
  59. AirConditionerState * AirConditioner::GetNormalTemperatureState()  
  60. {  
  61.     return m_pNormalTemperatureState;  
  62. }  
  63.   
  64.   
  65.   
  66.   
  67. //获取制冷状态  
  68. AirConditionerState * AirConditioner::GetRefrigerateState()  
  69. {  
  70.     return m_pRefrigerateState;  
  71. }  
  72.   
  73.   
  74.   
  75.   
  76. //获取制热状态  
  77. AirConditionerState * AirConditioner::GetHeatState()  
  78. {  
  79.     return m_pHeatState;  
  80. }  
  81.   
  82.   
  83.   
  84.   
  85.   
  86. //保持常温  
  87. void AirConditioner::KeepNormalTemperature()  
  88. {  
  89.     m_pCurState->KeepNormalTemperature(this);  
  90.       
  91. }  
  92.   
  93.   
  94.   
  95.   
  96. //制冷  
  97. void AirConditioner::refrigerate()  
  98. {  
  99.     m_pCurState->refrigerate(this);  
  100. }  
  101.   
  102.   
  103.   
  104.   
  105. //制热  
  106. void AirConditioner::Heat()  
  107. {  
  108.     m_pCurState->Heat(this);  
  109. }  
//构造函数
AirConditioner::AirConditioner(string strAirName, int nTemperature)
{
	m_strAirName = strAirName;
	m_nTemperature = nTemperature;

	m_pNormalTemperatureState = new NormalTemperatureState();
	m_pRefrigerateState = new RefrigerateState();
	m_pHeatState = new HeatState();

	m_pCurState = m_pNormalTemperatureState;
}



//虚构函数
AirConditioner::~AirConditioner()
{
	delete m_pNormalTemperatureState;
	m_pNormalTemperatureState = NULL;

	delete m_pRefrigerateState;
	m_pRefrigerateState = NULL;

	delete m_pHeatState;
	m_pHeatState = NULL;
}
	



//调节温度
void AirConditioner::SetTemperature(int nTemperature)
{
	m_nTemperature = nTemperature;
}



//获取温度
int AirConditioner::GetTemperature()
{
	return m_nTemperature;
}



//设置空调状态
void AirConditioner::SetAirConditionerState(AirConditionerState * pAirConditionerState)
{
	m_pCurState = pAirConditionerState;
}





//获取常温状态
AirConditionerState * AirConditioner::GetNormalTemperatureState()
{
	return m_pNormalTemperatureState;
}




//获取制冷状态
AirConditionerState * AirConditioner::GetRefrigerateState()
{
	return m_pRefrigerateState;
}




//获取制热状态
AirConditionerState * AirConditioner::GetHeatState()
{
	return m_pHeatState;
}





//保持常温
void AirConditioner::KeepNormalTemperature()
{
	m_pCurState->KeepNormalTemperature(this);
	
}




//制冷
void AirConditioner::refrigerate()
{
	m_pCurState->refrigerate(this);
}




//制热
void AirConditioner::Heat()
{
	m_pCurState->Heat(this);
}

    测试代码实现如下:

[cpp] view plain copy print ? 在CODE上查看代码片 派生到我的代码片
  1. #include <iostream>  
  2. #include "AirConditioner.h"  
  3.   
  4. using namespace std;  
  5.   
  6. int main()  
  7. {  
  8.   
  9.     AirConditioner * pAirConditioner = new AirConditioner("海尔空调", 25);  
  10.   
  11.     /****************常温状态*************************/  
  12.     pAirConditioner->KeepNormalTemperature();  
  13.   
  14.     cout << endl;  
  15.       
  16.     /****************制冷状态*************************/  
  17.     pAirConditioner->SetTemperature(33);  
  18.     pAirConditioner->refrigerate();  
  19.   
  20.     cout << endl;  
  21.   
  22.     /****************制热状态*************************/  
  23.     pAirConditioner->SetTemperature(15);  
  24.     pAirConditioner->Heat();  
  25.   
  26.     /****************销毁操作*************************/  
  27.     delete pAirConditioner;  
  28.     pAirConditioner = NULL;  
  29.   
  30.     return 0;  
  31. }  
#include <iostream>
#include "AirConditioner.h"

using namespace std;

int main()
{

	AirConditioner * pAirConditioner = new AirConditioner("海尔空调", 25);

	/****************常温状态*************************/
	pAirConditioner->KeepNormalTemperature();

	cout << endl;
	
	/****************制冷状态*************************/
	pAirConditioner->SetTemperature(33);
	pAirConditioner->refrigerate();

	cout << endl;

	/****************制热状态*************************/
	pAirConditioner->SetTemperature(15);
	pAirConditioner->Heat();

	/****************销毁操作*************************/
	delete pAirConditioner;
	pAirConditioner = NULL;

	return 0;
}

    编译并执行，结果如下:


    将具体行为封装在常温状态、制冷状态、制热状态中。空调类(也就是环境类)维持一个当前状态的引用，当客户端调用环境类的方法时，将该调用操作委托给具体状态类。具体状态类实现该状态下的行为，以及控制切换到其他状态。客户端无需直接操作具体的状态类，而是由环境类代为处理，降低了客户端与具体状态类的耦合性。如果需要添加具体的状态类也很容易，只需要继承于抽象状态类并对环境类稍加修改就可以了。另外，也避免了大量if...else臃肿语句，把这些条件判断都封装成一个个状态类。

3、使用环境类实现状态的转换

    在状态模式中实现状态转换时，具体状态类可通过调用环境类Context的setState()方法进行状态的转换操作，也可以统一由环境类Context来实现状态的转换。此时，增加新的具体状态类可能需要修改其他具体状态类或者环境类的源代码，否则系统无法转换到新增状态。但是对于客户端来说，无须关心状态类，可以为环境类设置默认的状态类，而将状态的转换工作交给具体状态类或环境类来完成，具体的转换细节对于客户端而言是透明的。

    在上面的“智能空调状态转换”实例中，我们通过具体状态类来实现状态的转换。除此之外，我们还可以通过环境类来实现状态转换，环境类作为一个状态管理器，统一实现各种状态之间的转换操作。

    下面通过简单实例来说明如何使用环境类实现状态转换：

 某软件公司某开发人员欲开发一个屏幕放大镜工具，其具体功能描述如下：用户单击“放大镜”按钮之后屏幕将放大一倍，再点击一次“放大镜”按钮屏幕再放大一倍，第三次点击该按钮后屏幕将还原到默认大小。

    State为抽象状态、NormalState为正常大小状态、LargerState为放大2倍大小状态、LargestState为放大4倍大小状态。Screen为屏幕类，也就是环境类Contex。

    屏幕类声明如下:

[cpp] view plain copy print ?
  1. //屏幕类  
  2. class Screen  
  3. {  
  4. private:  
  5.     //当前状态  
  6.     State * m_pState;  
  7.     //正常大小，2倍大小，4倍大小状态  
  8.     State * m_pNormalState;  
  9.     State * m_pLargerState;  
  10.     State * m_pLargestState;  
  11.   
  12. public:  
  13.     Screen();  
  14.     ~Screen();  
  15.       
  16.     //屏幕点击事件  
  17.     void OnClick();  
  18.   
  19.     //设置状态  
  20.     void SetState(State * pState);  
  21.   
  22. };  
//屏幕类
class Screen
{
private:
	//当前状态
	State * m_pState;
	//正常大小，2倍大小，4倍大小状态
	State * m_pNormalState;
	State * m_pLargerState;
	State * m_pLargestState;

public:
	Screen();
	~Screen();
	
	//屏幕点击事件
	void OnClick();

	//设置状态
	void SetState(State * pState);

};

    屏幕类实现代码如下：

[cpp] view plain copy print ?
  1. //构造函数  
  2. Screen::Screen()  
  3. {  
  4.     //创建正常大小、2倍大小、4倍大小对象  
  5.     m_pNormalState = new NormalState();  
  6.     m_pLargerState = new LargerState();  
  7.     m_pLargestState = new LargestState();  
  8.   
  9.     //初始状态为正常大小  
  10.     m_pState = m_pNormalState;  
  11.   
  12.     m_pState->Display();  
  13. }  
  14.   
  15.   
  16. //虚构函数  
  17. Screen::~Screen()  
  18. {     
  19.     if( NULL != m_pState )  
  20.     {  
  21.         delete m_pState;  
  22.   
  23.         m_pState = NULL;  
  24.     }  
  25. }  
  26.   
  27.   
  28. //设置状态  
  29. void Screen::SetState(State * pState)  
  30. {  
  31.     m_pState = pState;  
  32. }  
  33.   
  34.   
  35. //屏幕点击事件  
  36. void Screen::OnClick()  
  37. {  
  38.     if( m_pState == m_pNormalState )  
  39.     {  
  40.         SetState(m_pLargerState);  
  41.   
  42.         m_pState->Display();  
  43.     }  
  44.     else if( m_pState == m_pLargerState )  
  45.     {  
  46.         SetState( m_pLargestState );  
  47.   
  48.         m_pState->Display();  
  49.     }  
  50.     else if( m_pState == m_pLargestState )  
  51.     {  
  52.         SetState(m_pNormalState);  
  53.   
  54.         m_pState->Display();  
  55.     }  
  56. }  
//构造函数
Screen::Screen()
{
	//创建正常大小、2倍大小、4倍大小对象
	m_pNormalState = new NormalState();
	m_pLargerState = new LargerState();
	m_pLargestState = new LargestState();

	//初始状态为正常大小
	m_pState = m_pNormalState;

	m_pState->Display();
}


//虚构函数
Screen::~Screen()
{	
	if( NULL != m_pState )
	{
		delete m_pState;

		m_pState = NULL;
	}
}


//设置状态
void Screen::SetState(State * pState)
{
	m_pState = pState;
}


//屏幕点击事件
void Screen::OnClick()
{
	if( m_pState == m_pNormalState )
	{
		SetState(m_pLargerState);

		m_pState->Display();
	}
	else if( m_pState == m_pLargerState )
	{
		SetState( m_pLargestState );

		m_pState->Display();
	}
	else if( m_pState == m_pLargestState )
	{
		SetState(m_pNormalState);

		m_pState->Display();
	}
}

    抽象状态类和具体状态类声明如下：

[cpp] view plain copy print ?
  1. //抽象状态  
  2. class State  
  3. {  
  4. public:  
  5.     virtual void Display() = 0;  
  6. };  
  7.   
  8.   
  9. //正常大小状态  
  10. class NormalState : public State  
  11. {  
  12. public:  
  13.     virtual void Display();  
  14. };  
  15.   
  16.   
  17. //两倍大小状态  
  18. class LargerState  : public State  
  19. {  
  20. public:  
  21.     virtual void Display();  
  22. };  
  23.   
  24.   
  25. //四倍大小状态  
  26. class LargestState   : public State  
  27. {  
  28. public:  
  29.     virtual void Display();  
  30. };  
//抽象状态
class State
{
public:
	virtual void Display() = 0;
};


//正常大小状态
class NormalState : public State
{
public:
	virtual void Display();
};


//两倍大小状态
class LargerState  : public State
{
public:
	virtual void Display();
};


//四倍大小状态
class LargestState   : public State
{
public:
	virtual void Display();
};

    抽象状态类和具体状态类实现如下：

[cpp] view plain copy print ?
  1. void NormalState::Display()  
  2. {  
  3.     printf("正常大小\n");  
  4. }  
  5.   
  6.   
  7.   
  8. void LargerState::Display()  
  9. {  
  10.     printf("2倍大小\n");  
  11. }  
  12.   
  13.   
  14.   
  15. void LargestState::Display()  
  16. {  
  17.     printf("4倍大小\n");  
  18. }  
void NormalState::Display()
{
	printf("正常大小\n");
}



void LargerState::Display()
{
	printf("2倍大小\n");
}



void LargestState::Display()
{
	printf("4倍大小\n");
}

    测试代码实现如下:

[cpp] view plain copy print ?
  1. #include <stdio.h>  
  2. #include "State.h"  
  3.   
  4. int main()  
  5. {  
  6.   
  7.     Screen * pScreen = new Screen();  
  8.   
  9.     pScreen->OnClick();  
  10.     pScreen->OnClick();  
  11.     pScreen->OnClick();  
  12.       
  13.     delete pScreen;  
  14.     pScreen = NULL;  
  15.   
  16.     return 0;  
  17. }  
#include <stdio.h>
#include "State.h"

int main()
{

	Screen * pScreen = new Screen();

	pScreen->OnClick();
	pScreen->OnClick();
	pScreen->OnClick();
	
	delete pScreen;
	pScreen = NULL;

	return 0;
}

    编译并执行，结果如下:


    在上述代码中，所有的状态转换操作都由环境类Screen来实现，此时，环境类充当了状态管理器角色。如果需要增加新的状态，例如“八倍状态类”，需要修改环境类，这在一定程度上违背了“开闭原则”，但对其他状态类没有任何影响。这也是软件工程中的一种折中思想。

4、状态模式总结

    状态模式将一个对象在不同状态下的不同行为封装在一个个状态类中，通过设置不同的状态对象可以让环境对象拥有不同的行为。而状态转换的细节对于客户端而言是透明的，客户端不直接操作状态类，也就不需要知道状态转换细节，降低了客户端与具体状态类的耦合性。状态类和环境类是一种组合的关系，当客户端调用环境类的方法时，环境类将委托调用状态类的方法。使用状态模式封装了一个个具体的状态类，可以避免出现if...else拥挤情况，使得代码易于维护，也更具扩展性。同时封装一个个状态类，也体现了"单一原则"。在实际开发中，状态模式具有较高的使用频率。

1. 主要优点

    状态模式的主要优点如下：

    (1) 封装了状态的转换规则，在状态模式中可以将状态的转换代码封装在环境类或者具体状态类中，可以对状态转换代码进行集中管理，而不是分散在一个个业务方法中，符合"单一原则"。

    (2) 将所有与某个状态有关的行为放到一个类中，只需要注入一个不同的状态对象即可使环境对象拥有不同的行为。

    (3) 允许状态转换逻辑与状态对象合成一体，而不是提供一个巨大的条件语句块，状态模式可以让我们避免使用庞大的条件语句来将业务方法和状态转换代码交织在一起。

    (4) 可以让多个环境对象共享一个状态对象，从而减少系统中对象的个数。

2. 主要缺点

    状态模式的主要缺点如下：

    (1) 状态模式的使用必然会增加系统中类和对象的个数，导致系统运行开销增大。

    (2) 状态模式的结构与实现都较为复杂，如果使用不当将导致程序结构和代码的混乱，增加系统设计的难度。

    (3) 状态模式对“开闭原则”的支持并不太好，增加新的状态类需要修改那些负责状态转换的源代码，否则无法转换到新增状态；而且修改某个状态类的行为也需修改对应类的源代码。

3.适用场景

    在以下情况下可以考虑使用状态模式：

    (1) 对象的行为依赖于它的状态（如某些属性值），状态的改变将导致行为的变化。

    (2) 在代码中包含大量与对象状态有关的条件语句，这些条件语句的出现，会导致代码的可维护性和灵活性变差，不能方便地增加和删除状态，并且导致客户类与类库之间的耦合增强。

4.状态模式具体应用

    

    (1)电梯升降系统的设计: 存在打开、关闭、运行、停止状态。各个状态下将有不同的行为。例如:在运行状态下可以进行停止操作，但无法进行打开和关闭操作。


    (2)投票系统的设计: 投票1次则为正常投票状态、投票次数在2---5次之间则为重复投票状态、投票次数在5---8次之间则为恶意投票状态、投票次数大于8次则拉入黑名单状态。

     

    (3)酒店订房系统的设计:存在订房状态、入住状态、取消订状态、退房状态。各状态下对应有不同的行为。

    

    (4)超市、酒店、Ktv存在不同等级的用户，各等级用户处于不同状态，对应有不同权限的行为； 在游戏中也同样存在各种不同角色状态，各状态对应有不同的行为。

     

    (5)银行取款系统的设计:存在正常状态、透支状态、冻结状态。不同状态下将有不同行为。例如:冻结状态不能进行取款，而正常状态和透支状态可以进行取款操作。

    (6)操作系统的任务调度状态图: 存在等待状态、就绪状态、运行状态、停止状态。

    (7)TCP网络连接过程中，存在三次握手状态。发送连接请求、应答请求、建立连接、断开连接等状态。


    (8)数据库中的事务处理机制。存在OldClean状态、OldDirty状态、OldDelete状态、Deleted状态。

    (9)在工控领域，通信领域存在大量的状态图，某些芯片也存在时序图，高低电平的变化，系统时钟信号的变化，存在大量状态的变化。

    (10)生活中的状态模式: 从儿童到中年，再到老年，是人生状态的变化；从35度骤降到15度是气候的变化；白手起家到腰缠万贯是事业的变化。


pangshaohua
关注
专栏目录
C常用设计模式——状态模式
u012166632的专栏
09-25 889
文章首发于知乎专栏： https://zhuanlan.zhihu.com/c_1136684995157577728 个人公众号TarysThink 状态(State)模式，就是状态机嘛。状态机很常见，我们总能遇到带条件的状态跳转场景，比如红绿灯，绿灯亮的状态之后一定要进行关绿灯打开黄灯，进入下一个状态黄灯亮，再比如收音机，关闭状态的下一个动作一定是开机，收音机进入开机状态。那么状态...
C++设计模式——状态模式
swqqcs的专栏
09-09 1059
在阐述状态模式之前，先来看一个例子。一个银行取款问题: 如果账户余额大于0，则正常取款；如果余额在-2000和0之间，则透支取款；如果余额小于-2000，则账户处于冻结状态，无法进行取款操作。     实现代码如下: //银行账户 class Account { private: //余额 int m_nBalance; public: //取款操作 void WithDr
设计模式之状态模式
baidu_41388533的博客
08-04 326
目录 状态模式state 概念 模式选择 角色和职责 案例 状态模式state 概念 State模式也叫状态模式，是行为设计模式的一种。State模式允许通过改变对象的内部状态而改变对象的行为，这个对象表现得就好像修改了它的类一样。 状态模式主要解决的是当控制一个对象状态转换的条件表达式过于复杂时的情况。把状态的判断逻辑转译到表现不同状态的一系列类当中，可以把复杂的判断逻辑简化。 模式选择 角色和职责 Context：用户对象 拥有一个State类型的成员，以标识对象的当前状态.
c++设计模式（状态模式）
浮尘丶若梦
03-05 264
GOOD：当一个对象的行为取决于它的状态，并且它必须在运行时刻根据状态改变它的行为时，可考虑用到状态模式。 　 　例 #include <iostream> using namespace std;class Work; class ForenoonState; class NoonState;class State { public: virtual void WriteProgram
C++设计模式之享元模式（Flyweight）
08-27
C++设计模式之享元模式（Flyweight） C++设计模式之享元模式（Flyweight）是一种结构型设计模式，主要用于解决大量相似对象的创建和操作所带来的内存负载问题。该模式的主要设计目标是通过共享对象来减少内存负载，...
设计模式C++学习之状态模式（State）
09-07
状态模式是一种行为设计模式，它允许对象在内部状态改变时改变其行为，对象看起来似乎修改了它的类。这种模式常用于处理对象的状态变化，并且使代码结构清晰，易于维护。 在C++中，状态模式通常包含以下几个关键...
c++设计模式-行为型模式-状态模式
06-20
c++设计模式-行为型模式-状态模式；qt工程；c++简单源码； 状态（State）模式的定义：对有状态的对象，把复杂的“判断逻辑”提取到不同的状态对象中，允许状态对象在其内部状态发生改变时改变其行为。
C++设计模式：状态模式
zusi_csdn
11-25 242
一、源代码： #include&lt;iostream&gt; #include&lt;memory&gt; using namespace std; class State; class Context { public: Context() { this-&gt;_state = nullptr; } void setState(shar...
设计模式 - 状态模式(C++实例)
11-30
分享关于状态模式的c++实现，若理解有误，还请指正。
c++状态模式
12-21
C++状态模式
C++设计模式--状态模式
lihaidong的博客
07-14 230
状态模式（State Pattern） 定义 在不破坏封装性的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态。这样以后就可以将该对象恢复到原先的状态 State类，抽象状态类，定义一个接口以封装与Context的一个特定状态相关的行为。 ConcreteState类，具体状态，每一个子类实现一个与Context的一个状...
C++设计模式——状态模式（State）
qq_33766994的博客
03-30 238
状态模式 在软件构建过程中，某些对象的状态变化会导致行为也随之变化。允许一个对象在其内部状态改变时改变它的行为，使对象看起来似乎修改了其行为。 enum NetworkState{ Network_Open, Network_Close, Network_Connect, }; class NetworkProcessor{ NetworkState state; public: void Operation1(){ if (state == Netw
C++设计模式--状态模式(state)
luoyayun361的专栏
03-02 1236
概述 前面文章介绍了代理模式（在这里），代理模式和状态模式都提供一个代理类，从结构上看，可以认为代理模式只是状态模式的一个特例，不同之处在于，代理模式控制对其实现类的访问，而状态模式动态地改变其实现类，当发现大多数或者所有函数都存在条件代码时，这种模式很有用。 状态模式 简单来说，状态模式通过一个前端对象来使用后端实现对象履行其职责，在前端对象生存期期间，状态模式从一个实现对象到另一个实现对象进行...
C++设计模式之状态模式(行为型模式)
cfl927096306的博客
04-30 1075
什么是状态模式 在本文末尾会给出解释，待耐心看完demo再看定义，相信你会有更深刻的印象 实例讲解 背景 假设我们正在为客户开发一款糖果机产品，客户不是软件专家，他们只甩给了我们一个图，他们认为糖果机的控制器需要如下图般这样工作 赶紧脑补一下糖果机是什么样子的？ 客户给的是一个状态图，一共有4个状态：没有1块钱、有1块钱、售出糖果、糖果售罄 很容易想到的就是，写一个 CandyMachine ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值