[结构型模式] 桥接模式的理解

谁践踏了优雅 2022-04-11 04:59 113阅读 0赞

\[img\]http://api5.yunpan.360.cn/intf.php?method=File.getThumbByNid&qid=108635719&nid=13770720602900100&size=800\_600&devtype=web&v=1.0.1&rtick=14661263963507&sign=9de2d2234b58f8d1ddd7780feae1449e&\[/img\]  
\[img\]http://api5.yunpan.360.cn/intf.php?method=File.getThumbByNid&qid=108635719&nid=14661242719454639&size=800\_600&devtype=web&v=1.0.1&rtick=14661265101226&sign=4c664f5e32882fd5510dfdc95191e0c8&\[/img\]  
\[img\]http://api5.yunpan.360.cn/intf.php?method=File.getThumbByNid&qid=108635719&nid=14661242729456849&size=800\_600&devtype=web&v=1.0.1&rtick=14661265102204&sign=68118c12ff14ecefd8669ff1f337c356&\[/img\]  
\[color=red\]\[b\]头文件\[/b\]\[/color\]

//BridgePattern.h
    
    #ifndef BRIDGEPATTERN_H
    #define BRIDGEPATTERN_H
    
    #include <Windows.h>
    
    namespace BridgePattern
    {
       
        // Base Class
        //
        class Implementor
        {
       
        public:
            Implementor();
            virtual ~Implementor();
            virtual void OperationImpl() = 0;
        };
    
        class ConcreteImplementorA : public Implementor
        {
       
        public:
            ConcreteImplementorA();
            virtual ~ConcreteImplementorA();
            virtual void OperationImpl();
        };
    
        class ConcreteImplementorB : public Implementor
        {
       
        public:
            ConcreteImplementorB();
            virtual ~ConcreteImplementorB();
            virtual void OperationImpl();
        };
    
    
        // Base Class
        //
        class Abstraction
        {
       
        public:
            Abstraction();
            virtual ~Abstraction();
            virtual void Operation() = 0;
        };
    
        class ConcreteAbstractionA : public Abstraction
        {
       
        public:
            ConcreteAbstractionA(Implementor* pImplementor);
            virtual ~ConcreteAbstractionA();
            virtual void Operation();
    
        private:
            Implementor* m_pImplementor;
        };
    
        class ConcreteAbstractionB : public Abstraction
        {
       
        public:
            ConcreteAbstractionB(Implementor* pImplementor);
            virtual ~ConcreteAbstractionB();
            virtual void Operation();
    
        private:
            Implementor* m_pImplementor;
    
        };
    
        //
        void BridgePattern_Test_A();
        void BridgePattern_Test_B();
    }
    
    #endif

\[color=red\]\[b\]实现\[/b\]\[/color\]

#include "BridgePattern.h"
    #include <iostream>
    using namespace std;
    
    namespace BridgePattern
    {
       
        // Base Class
        //
        Implementor::Implementor()
        {
       
        }
    
        Implementor::~Implementor()
        {
       
        }
    
    
        ConcreteImplementorA::ConcreteImplementorA()
        {
       
        }
        ConcreteImplementorA::~ConcreteImplementorA()
        {
       
        }
        void ConcreteImplementorA::OperationImpl()
        {
       
            cout << "ConcreteImplementorA::OperationImpl\n";
        }
    
        ConcreteImplementorB::ConcreteImplementorB()
        {
       
        }
        ConcreteImplementorB::~ConcreteImplementorB()
        {
       
        }
        void ConcreteImplementorB::OperationImpl()
        {
       
            cout << "ConcreteImplementorB::OperationImpl\n";
        }
    
    
        // Base Class
        //
        Abstraction::Abstraction( )
        {
       
        }
        Abstraction::~Abstraction()
        {
       
        }
    
        ConcreteAbstractionA::ConcreteAbstractionA(Implementor* pImplementor)
            : m_pImplementor(NULL)
        {
       
            if (NULL == m_pImplementor)
            {
       
                m_pImplementor = pImplementor;
            }
        }
        ConcreteAbstractionA::~ConcreteAbstractionA()
        {
       
            if (m_pImplementor != NULL)
            {
       
                delete m_pImplementor;
                m_pImplementor = NULL;
            }
        }
        void ConcreteAbstractionA::Operation()
        {
       
            m_pImplementor->OperationImpl();
            cout << "ConcreteAbstractionA::Operation\n";
        }
    
        ConcreteAbstractionB::ConcreteAbstractionB(Implementor* pImplementor)
            : m_pImplementor(NULL)
        {
       
            if (NULL == m_pImplementor)
            {
       
                m_pImplementor = pImplementor;
            }
        }
        ConcreteAbstractionB::~ConcreteAbstractionB()
        {
       
            if (m_pImplementor != NULL)
            {
       
                delete m_pImplementor;
                m_pImplementor = NULL;
            }
        }
        void ConcreteAbstractionB::Operation()
        {
       
            m_pImplementor->OperationImpl();
            cout << "ConcreteAbstractionB::Operation\n";
        }
    
    
        //
        void BridgePattern_Test_A()
        {
       
            ConcreteAbstractionA* pAbstraction = new ConcreteAbstractionA(new ConcreteImplementorA());
    
            pAbstraction->Operation();
    
            delete pAbstraction;
            pAbstraction = NULL;
        }
    
        void BridgePattern_Test_B()
        {
       
            ConcreteAbstractionB* pAbstraction = new ConcreteAbstractionB(new ConcreteImplementorB());
    
            pAbstraction->Operation();
    
            delete pAbstraction;
            pAbstraction = NULL;
        }
    }

\[color=red\]\[b\]客户端\[/b\]\[/color\]

#include "BridgePattern.h"
    
    #include <iostream>
    using namespace std;
    using namespace BridgePattern;
    
    void main()
    {
       
        BridgePattern_Test_A();
        BridgePattern_Test_B();
    }

\[color=red\]\[b\]运行结果\[/b\]\[/color\]  
\[img\]http://api5.yunpan.360.cn/intf.php?method=File.getThumbByNid&qid=108635719&nid=14661266159472768&size=800\_600&devtype=web&v=1.0.1&rtick=14661266151738&sign=6f28b53536e902f6a1969a678585db06&\[/img\]