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

[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]