动机

  • 在软件构建过程中，某些对象的状态如果改变，其行为也会随之发生变化，比如文档处于只读状态，其支持的行为和读写状态支持就可能完全不同。
  • 如何在运行是根据对象的状态来透明地更改对象地行为？而不会为对象操作和状态转化之间引入紧耦合？

    模式定义

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

    未使用该模式

    ```cpp enum NetworkState { Network_Open, Network_Close, Network_Connect, //如果添加wait状态，则需在代码中做很多地修改 Network_Wait, };

class NetworkProcessor { NetworkState state; public: void Operation1() { if (state == Network_Open) { //** state = Network_Close; } else if (state == Network_Close) { //…………. state = Network_Connect; } else if (state == Network_Connect) { //$ state = Network_Open; } }

  1. void Operation2() {
  2.     if (state == Network_Open) {
  3.         //************
  4.         state = Network_Connect;
  5.     }
  6.     else if (state == Network_Close) {
  7.         //.............
  8.         state = Network_Open;
  9.     }
  10.     else if (state == Network_Connect) {
  11.         //$$$$$$$$$$$$$
  12.         state = Network_Close;
  13.     }
  14. }

};

  1. <a name="ADkHi"></a>
  2. ### 实现1
  3. ```cpp
  4. class NetworkState
  5. {
  6. public:
  7.     NetworkState* pNext;
  8.     virtual void Operation1() = 0;
  9.     virtual void Operation2() = 0;
  10.     virtual void Operation3() = 0;
  12.     virtual ~NetworkState() {}
  13. };
  15. class OpenState : public NetworkState
  16. {
  17.     static NetworkState* m_instance;
  18. public:
  19.     static NetworkState* getInstance() {
  20.         if (m_instance == nullptr) {
  21.             m_instance = new OpenState();
  22.         }
  23.         return m_instance;
  24.     }
  26.     void Operation1() {
  27.         //*************
  28.         pNext = CloseState::getInstace();
  29.     }
  30.     void Operation2() {
  31.         //.............
  32.         pNext = ConnectState::getInstance();
  33.     }
  34.     void Operation3() {
  35.         pNext = OpenState::getInstance();
  36.     }
  37. };
  39. class OpenState : public NetworkState
  40. {
  41.     static NetworkState* m_instance;
  42. public:
  43.     static NetworkState* getInstance() {
  44.         if (m_instance == nullptr) {
  45.             m_instance = new OpenState();
  46.         }
  47.         return m_instance;
  48.     }
  50.     void Operation1() {
  51.         //*************
  52.         pNext = CloseState::getInstance();
  53.     }
  54.     void Operation2() {
  55.         //.............
  56.         pNext = ConnectState::getInstance();
  57.     }
  58.     void Operation3() {
  59.         pNext = OpenState::getInstance();
  60.     }
  61. }; 
  63. class CloseState : public NetworkState
  64. {
  66. };
  68. class NetworkProcessor {
  69.     NetworkState* pState;
  70. public:
  71.     NetworkProcessor(NetworkState* pState) {
  72.         this->pState = pState;
  73.     }
  75.     void Operation1() {
  76.         //...
  77.         pState->Operation1();
  78.         pState = pState->pNext;
  79.         //...
  80.     }
  82.     void Operation2() {
  83.         //...
  84.         pState->Operation2();
  85.         pState = pState->pNext;
  86.     }
  88.     void Operation3() {
  90.     }
  91. };

要点总结

  • State模式将所有与一个特定状态相关的行为都放进一个State的子对象中，在对象状态切换时，切换相应的对象；但同时维持State的接口，这样实现了具体操作与状态转换之间的解耦。
  • 为不同的状态引入不同的对象使得状态转换变得更加明确，而且可以保证不会出现状态不一致的情况，因为转换是原子性的——即要么彻底转换过来，要么不转换。
  • 如果State对象没有实例变量，要么各个上下文可以共享一个State对象，从而节省对象开销。