设计模式状态模式与职责链模式

谁借莪１个温暖的怀抱￠ 2023-02-13 08:52 3阅读 0赞

1.  状态模式  
    状态模式，当一个对象的内在状态改变时允许改变其行为，这个对象看起来像是改变了其类。  
    状态模式主要解决的是当控制一个对象状态转换的条件表达式过于复杂时的情况。把状态的判断逻辑转移到表示不同状态的一系列类当中，可以把复杂的判断逻辑简化。  
    ![状态模式结构图][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTQxMzMyOA_size_16_color_FFFFFF_t_70]

#include <iostream>
    #include <string>
    #include <vector>
    
    using namespace std;
    class War;
    class State
    { 
    public:
        virtual void Prophase() { }
        virtual void Metaphase() { }
        virtual void Anaphase() { }
        virtual void End() { }
        virtual void CurrentState(War *war) { }
    };
    //战争
    class War
    { 
    private:
        State *m_state;  //目前状态
        int m_days;      //战争持续时间
    public:
        War(State *state)
                : m_state(state),
                  m_days(0)
        { }
        ~War()
        { 
            delete m_state;
        }
        int GetDays()
        { 
            return m_days;
        }
        void SetDays(int days)
        { 
            m_days = days;
        }
        void SetState(State *state)
        { 
            delete m_state; m_state = state;
        }
        void GetState()
        { 
            m_state->CurrentState(this);
        }
    };
    
    //战争结束
    class EndState: public State
    { 
    public:
        void End(War *war) //结束阶段的具体行为
        { 
            cout<<"战争结束"<<endl;
        }
        void CurrentState(War *war) {  End(war); }
    };
    //后期
    class AnaphaseState: public State
    { 
    public:
        void Anaphase(War *war) //后期的具体行为
        { 
            if(war->GetDays() < 30)
                cout<<"第"<<war->GetDays()<<"天：战争后期，双方拼死一搏"<<endl;
            else
            { 
                war->SetState(new EndState());
                war->GetState();
            }
        }
        void CurrentState(War *war) {  Anaphase(war); }
    };
    //中期
    class MetaphaseState: public State
    { 
    public:
        void Metaphase(War *war) //中期的具体行为
        { 
            if(war->GetDays() < 20)
                cout<<"第"<<war->GetDays()<<"天：战争中期，进入相持阶段，双发各有损耗"<<endl;
            else
            { 
                war->SetState(new AnaphaseState());
                war->GetState();
            }
        }
        void CurrentState(War *war) {  Metaphase(war); }
    };
    //前期
    class ProphaseState: public State
    { 
    public:
        void Prophase(War *war)  //前期的具体行为
        { 
            if(war->GetDays() < 10)
                cout<<"第"<<war->GetDays()<<"天：战争初期，双方你来我往，互相试探对方"<<endl;
            else
            { 
                war->SetState(new MetaphaseState());
                war->GetState();
            }
        }
        void CurrentState(War *war) {  Prophase(war); }
    };
    
    int main()
    { 
        War *war = new War(new ProphaseState());
        for(int i = 1; i < 40;i += 5)
        { 
            war->SetDays(i);
            war->GetState();
        }
        delete war;
        return 0;
    }

1.  职责链模式  
    职责链模式：使多个对象都有机会处理请求，从而避免请求的发送者和接收者之间的耦合关系。将这个对象连城一条链，并沿着这条链传递该请求，直到有一个对象处理它为止。  
    ![职责链模式结构图][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTQxMzMyOA_size_16_color_FFFFFF_t_70 1]

#include <iostrem>
    #include <string> 
    using namespace std;  
    
    class Handler 
    { 
     public:         
     Handler(Handler* pstHandler): 
     m_pstHandler(pstHandler)         
     {           
     };  
     protected:         
     Handler* m_pstHandler; 
     };  
    
    class ConcreteHandler1: public Handler 
    {   
       public:         
       ConcreteHandler1(Handler* pstHandler): Handler(pstHandler)         
       {           
       }          
      virtual void HandleRequest(int request)         
      { 
         if(request < 7)                 
           {                          
              cout<< "组长：批假"<< request<< "天"<< endl;
           }                 
           else                 
           {                          
              m_pstHandler->HandleRequest(request);                 
           }         
       } 
    };  
    
    class ConcreteHandler2: public Handler 
    { 
     public:
          ConcreteHandler2(Handler* pstHandler): Handler(pstHandler)        
          {           
          }         
          virtual void HandleRequest(int request)         
          {                  
              if(request < 15)                
               {                         
                   cout<< "总监：批假"<< request<< "天"<< endl;                 
               }                 
               else                
               {                          
                   m_pstHandler->HandleRequest(request);                 
               }        
           } 
    };  
    
    class ConcreteHandler3: public Handler 
    { 
     public:     
         ConcreteHandler3(Handler* pstHandler): Handler(pstHandler)     
         {           
         }          
         virtual void HandleRequest(int request)    
         {                  
             if(request < 30)                 
             {                     
                  cout<< "经理：批假"<< request<< "天"<< endl;                 
             }                 
             else                 
             {                      
                 cout<< "经理："<< request<< "天，时间太长，超过公司规定"<< endl;                 	               	 	};  
    };
    
    int main(int argc, char* argv[]) 
    {       
       Handler* jingli = new ConcreteHandler3(NULL);         
       Handler* zongjian = new ConcreteHandler2(jingli);         
       Handler* zuzhang = new ConcreteHandler1(zongjian);          
       zuzhang->HandleRequest();         
       zuzhang->HandleRequest();         
       zuzhang->HandleRequest();         
       zuzhang->HandleRequest();          
       delete jingli;         
       delete zongjian;         
       delete zuzhang;          
    }

1.  状态模式与职责链模式的区别

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTQxMzMyOA_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200528101432777.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTQxMzMyOA==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTQxMzMyOA_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20200528102626387.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTQxMzMyOA==,size_16,color_FFFFFF,t_70