`

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

 
阅读更多



头文件
//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

实现
#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;
    }
}

客户端
#include "BridgePattern.h"

#include <iostream>
using namespace std;
using namespace BridgePattern;

void main()
{
    BridgePattern_Test_A();
    BridgePattern_Test_B();
}

运行结果
分享到:
评论

相关推荐

    结构型模式之桥接模式(bridge)

    桥接模式是设计模式中的一种结构型模式,其主要目的是为了分离抽象部分和实现部分,以便两者能够独立地进行变化。这种模式的核心理念是通过引入一个抽象层来封装多种可能的实现,使得抽象和实现之间形成一种“桥接”...

    Bridge 桥接模式(结构型模式)

    视频资源“7.Bridge 桥接模式(结构型模式).wmv”可能涵盖了以下内容: 1. 桥接模式的概念解释和基本结构。 2. 桥接模式的UML类图展示,解释各个角色之间的关系。 3. 实例演示,如图形界面库的设计,其中颜色和形状是...

    设计模式面面观(10):桥接模式(Bridge Pattern)-结构型模式

    创建型模式 (100%) 设计模式面面观(8):创建型模式总结 (100%) 设计模式面面观(9):适配器模式(Adapter Pattern)-结构型模式 (100%) 设计模式面面观(10):桥接模式(Bridge Pattern)-结构型模式 ...

    设计模式---桥接模式

    桥接模式是一种结构型设计模式,它将抽象部分与实现部分分离,使它们可以独立进行变化。这种模式在软件工程中被广泛应用于处理组件之间的耦合问题,特别是当需要为同一抽象提供多种实现或者需要独立地改变它们时。 ...

    设计模式的桥接模式的例子

    桥接模式是设计模式中的一种结构型模式,它旨在将抽象部分与实现部分解耦,使得它们可以独立地变化。这种模式将抽象类和它的实现类进行分离,通过一个抽象接口来连接它们,使得两者可以独立发展,增加了系统的灵活性...

    设计模式之结构型模式

    用户可以通过这个框架来理解和实践结构型模式,如适配器和桥接模式。 总结来说,结构型设计模式是软件设计中的关键组成部分,它们提供了解决组件之间结构复杂性的方法。适配器模式和桥接模式分别处理接口不兼容和...

    设计模式 - 桥接模式

    桥接模式是一种结构型设计模式,它将抽象部分与实现部分分离,使它们可以独立进行变化。这种模式在软件工程中被广泛应用于处理组件之间的耦合问题,使得系统具有更好的可扩展性和灵活性。 桥接模式的主要组成部分...

    iOS 设计模式 桥接模式

    桥接模式是设计模式中的一种结构型模式,它旨在将抽象部分与实现部分解耦,使得两者可以独立地进行变化。在iOS开发中,尤其是在构建可扩展和灵活的代码架构时,这种模式显得尤为重要。iOS应用程序往往需要适配不同的...

    桥接模式 C++ 实现

    总结来说,桥接模式是一种结构型设计模式,通过将抽象和实现解耦,使得两者可以独立发展。在C++中,我们可以利用类的继承和接口来实现这一模式,从而提高代码的可扩展性和可维护性。在实际项目中,尤其是在需要处理...

    23种设计模式,创建型模式共5种,结构型模式7种,行为型模式11种

    设计模式分为三大类:创建型模式、结构型模式和行为型模式。 **创建型模式**关注的是对象的创建。共有五种创建型模式: 1. **工厂方法模式**:它定义一个用于创建对象的接口,让子类决定实例化哪一个类。工厂方法...

    桥接模式-设计模式

    桥接模式是一种结构型设计模式,它将抽象部分与实现部分分离,使它们可以独立进行变化。这种模式在软件设计中扮演着重要的角色,尤其是在面对需求频繁变动或系统需要支持多平台、多设备的情况下。 首先,我们要理解...

    设计模式 桥接&装饰模型实验

    **桥接模式**是一种结构型设计模式,它的主要目的是将抽象部分与实现部分分离,使得它们可以独立地进行变化。在桥接模式中,抽象类不包含具体的实现,而是持有对实现类的引用。这样,我们可以改变抽象和实现之间的...

    设计模式之结构型模式uml类图EA文件.rar

    在给定的压缩包文件中,我们关注的是结构型设计模式,这些模式主要用于处理类和对象的组合与结构,以实现更灵活、可扩展的设计。下面我们将详细探讨其中涉及到的几个模式:桥接模式、适配器模式、装饰者模式和组合...

    桥接模式例子源码

    桥接模式是一种设计模式,属于结构型模式,其主要目的是将抽象部分与实现部分分离,使得它们可以独立地进行变化。这种模式通过引入一个抽象化角色来实现抽象部分与实现部分的解耦,使得这两部分可以独立扩展。在这个...

    设计模式11桥接模式

    该模式属于对象结构型模式,有时也被称为柄体(Handle and Body)模式或接口(Interface)模式。 **英文定义**:“Bridge Pattern: Decouple an abstraction from its implementation so that the two can vary ...

    Java设计模式之结构型模式源码以及文档

    结构型模式可以分为七种:适配器模式、桥接模式、组合模式、装饰模式、外观模式、享元模式和代理模式。这些模式在不同的场景下有着各自的用途,它们可以帮助我们构建出灵活、可扩展的系统。 适配器模式允许两个不...

Global site tag (gtag.js) - Google Analytics