设计模式--行为型模式之八--State

意图：

允许一个对象在其内部状态改变时改变他的行为

适用性：

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

2一个操作中含有庞大的多分支的条件语句，且这些分支依赖于该对象的状态。这种模式将每一个条件分支放入一个独立的类中，根据对象自身的状态将对象的状态作为一个对象

效果：

1它将与特定状态相关的行为局部化，并且将不同状态的行为分割开来

2 它使得状态显式化，从Context角度来看，状态转换是原子的，只需重新邦定一个变量即可

3 State对象可被共享

 

实现：

1谁定义状态转换  State模式不指定哪一个参与者定义状态转换规则，如果是固定的，则可以在Context中完全实现

2创建和销毁State对象 

当将要进入的状态在运行时是不可知的，并且上下文不经常改变状态时，仅当需要State对象时才创建他们并随后销毁它们

当状态改变很频繁时，采用提前创建他们并始终不销毁它们的方法

 

 

The sample code is as below:

State.h

 

1. #include <iostream>
2. using namespace std;
3. class TCPState;
4. class TCPConnection
5. {
6. public:
7.     TCPConnection();
8.     void ActiveOpen();
9.     void PassiveOpen();
10.     void Close();
11.     void Send();
12.     //void Acknowledge();
13.     //void Synchronize();
14.         void ChangeState(TCPState*);
15. protected:
16.     friend class TCPstate;
18. private:
19.     TCPState* _state;
20. };
22. class TCPState
23. {
24. public:
25.     virtual void Transmit(TCPConnection*);
26.     virtual void ActiveOpen(TCPConnection*);
27.     virtual void PassiveOpen(TCPConnection*);
28.     virtual void Close(TCPConnection*);
29. //  virtual void Synchronize(TCPConnection*);
30. //  virtual void Acknowledge(TCPConnection*);
31. //  virtual void Send(TCPConnection*);
32. protected:
33.     void ChangeState(TCPConnection*,TCPState*);
34. };
36. class TCPEstablished : public TCPState
37. {
38. public:
39.     static TCPState* Instance();
40. //  virtual void Transmit(TCPConnection*);
41.     virtual void Close(TCPConnection*);
42. private:
43.     static TCPState* _instance;
44. };
46. class TCPListen : public TCPState
47. {
48. public:
49.     static TCPState* Instance();
50.     //virtual void Send(TCPConnection*);
51. private:
52.     static TCPState* _instance;
53. };
55. class TCPClosed :public TCPState
56. {
57. public:
58.     TCPClosed() {cout<<"TCPClosed is created"<<endl;}
59.     static TCPState* Instance();
60.     virtual void ActiveOpen(TCPConnection*);
61.     virtual void PassiveOpen(TCPConnection*);
62. private:
63.     static TCPState* _instance;
64. };

 State.cpp

1. #include "State.h"
2. #include <iostream>
3. using namespace std;
4. TCPState* TCPClosed::_instance =0;
5. TCPState* TCPListen::_instance=0;
6. TCPState* TCPEstablished::_instance=0;
7. TCPState* TCPClosed::Instance()
8. {
9.     if (_instance == 0)
10.     {
11.         _instance = new TCPClosed;
12.     }
13.     cout<<"Change the state to TCPClosed"<<endl;
14.     return _instance;
15. }
16. TCPState* TCPListen::Instance()
17. {
18.     if (_instance == 0)
19.     {
20.         _instance = new TCPListen;
21.     }
22.     cout<<"Change the state to TCPListen"<<endl;
23.     return _instance;
24. }
25. TCPState* TCPEstablished::Instance()
26. {
27.     if (_instance == 0)
28.     {
29.         _instance = new TCPEstablished;
30.     }
31.     cout<<"Change the state to TCPEstablished"<<endl;
32.     return _instance;
33. }
34. TCPConnection::TCPConnection()
35. {
36.     _state = TCPClosed::Instance();
37. }
38. void TCPConnection::ChangeState(TCPState* s)
39. {
40.     _state = s;
41. }
42. void TCPConnection::ActiveOpen()
43. {
44.     _state->ActiveOpen(this);
45. }
46. void TCPConnection::PassiveOpen()
47. {
48.     _state->PassiveOpen(this);
49. }
50. void TCPConnection::Close()
51. {
52.     _state->Close(this);
53. }
54. void TCPConnection::Send()
55. {
56.     _state->Transmit(this);
57. }
58. void TCPState::Transmit(TCPConnection*)
59. {
60.     cout<<"TCP in Transmit state"<<endl;
61. }
62. void TCPState::ActiveOpen(TCPConnection*)
63. {
64.     cout<<"TCP in Active open state"<<endl;
65. }
66. void TCPState::PassiveOpen(TCPConnection*)
67. {
68.     cout<<"TCP in passive open state"<<endl;
69. }
70. void TCPState::Close(TCPConnection*)
71. {
72.     cout<<"TCP in close state"<<endl;
73. }
74. void TCPState::ChangeState(TCPConnection* t,TCPState* s)
75. {
76.     t->ChangeState(s);
77. }
78. void TCPClosed::ActiveOpen(TCPConnection* t)
79. {
80.     cout<<"TCPClosed send SYN,receive SYN,ACK"<<endl;
81.     ChangeState(t,TCPEstablished::Instance());
82. }
83. void TCPClosed::PassiveOpen(TCPConnection* t)
84. {
85.     ChangeState(t,TCPEstablished::Instance());
86. }
87. void TCPEstablished::Close(TCPConnection* t)
88. {
89.     cout<<"TCPEstablished send FIN,receive ACK of FIN"<<endl;
90.     ChangeState(t,TCPEstablished::Instance());
91. }

main.cpp

1. #include "State.h"
2. #include <iostream>
3. using namespace std;
4. int main()
5. {
6.     TCPConnection a;
7.     a.ActiveOpen();
8.     a.Close();
9.     return 0;
11. }