23种设计模式之六（结构型模式）Bridge模式

一、简介

        Bridge模式是为了解决将将抽象部份与它的实现部分分离，即将抽象（Abstraction）与实现（AbstractionImp）分离，使得二者可以独立地变化，从而尽可能地提高系统模块内部的内聚(Cohesion)、尽可能降低模块间的耦合(Coupling)。

        Bridge桥接模式号称设计模式中最难理解的模式之一，关键就是这个抽象和实现的分离非常让人奇怪，大部分人刚看到这个定义的时候都会认为实现就是继承自抽象，那怎么可能将他们分离呢。它也是也是 OO 开发与设计中经常会用到的模式之一，使用组合（委托）的方式将抽象和实现彻底地解耦，这样的好处是抽象和实现可以分别独立地变化，系统的耦合性也得到了很好的降低。

        如下图是Bridge模式的结构图，其中系统被分为两个相对独立的部分，左边是抽象部分，右边是实现部分。这两个部分可以互相独立地进行修改，例如当需要从Abstraction派生一个具体子类RefinedAbstractionB时候，不需要添加和修改ConcreteAbstractionImpA和ConcreteAbstractionImpB；当Operation的操作由于算法或逻辑改变只需在右边添加一个具体化子类ConcreteAbstractionImpC，其他的都不用改变。

二、详解

1、代码实现

（1）代码abstraction.h：

#ifndef _ABSTRACTION_H_
#define _ABSTRACTION_H_

class Abstraction
{
    public:
        virtual ~Abstraction();
        virtual void Operation() = 0;
    protected:
        Abstraction();
    private:
};

class AbstractionImp;
class RefinedAbstraction : public Abstraction
{
    public:
        RefinedAbstraction(AbstractionImp *imp);
        ~RefinedAbstraction();
        void Operation();
    protected:
    private:
        AbstractionImp *_imp;
};

#endif

（2）代码abstraction.cpp：

#include <iostream>
#include "abstraction.h"
#include "abstractionimp.h"
using namespace std;

Abstraction::Abstraction()
{
}

Abstraction::~Abstraction()
{
}

RefinedAbstraction::RefinedAbstraction(AbstractionImp *imp)
{
    _imp = imp;
}

RefinedAbstraction::~RefinedAbstraction()
{
}

void RefinedAbstraction::Operation()
{
	  cout<<"_imp->Operation() interface"<<endl;
    _imp->Operation();
}

（3）代码abstractionimp.h：

#ifndef _ABSTRACTIONIMP_H_
#define _ABSTRACTIONIMP_H_

class AbstractionImp
{
    public:
        virtual ~AbstractionImp();
        virtual void Operation() = 0;
    protected:
        AbstractionImp();
    private:
};

class ConcreteAbstractionImpA : public AbstractionImp
{
    public:
        ConcreteAbstractionImpA();
        ~ConcreteAbstractionImpA();
        void Operation();
    protected:
    private:
};

class ConcreteAbstractionImpB : public AbstractionImp
{
    public:
        ConcreteAbstractionImpB();
        ~ConcreteAbstractionImpB();
        void Operation();
    protected:
    private:
};

#endif

（4）代码abstractionimp.cpp：

#include <iostream>
#include "abstractionimp.h"
using namespace std;

AbstractionImp::AbstractionImp()
{
	  cout << "---AbstractionImp constructor" <<endl;
}

AbstractionImp::~AbstractionImp()
{
}

void AbstractionImp::Operation()
{
    cout << "AbstractionImp...imp..." <<endl;
}

ConcreteAbstractionImpA::ConcreteAbstractionImpA()
{
}

ConcreteAbstractionImpA::~ConcreteAbstractionImpA()
{
}

void ConcreteAbstractionImpA::Operation()
{
    cout<< "+++ConcreteAbstractionImpA..." <<endl;
}

ConcreteAbstractionImpB::ConcreteAbstractionImpB()
{
}

ConcreteAbstractionImpB::~ConcreteAbstractionImpB()
{
}

void ConcreteAbstractionImpB::Operation()
{
    cout<< "+++ConcreteAbstractionImpB..." <<endl;
}

（5）代码main.cpp：

#include <iostream>
#include "abstraction.h"
#include "abstractionimp.h"
using namespace std;

int main()
{
    //Bridge模式将抽象和实现分别独立实现
    //实现部分ConcreteAbstractionImplementA
    AbstractionImp *imp = new ConcreteAbstractionImpA();
    //抽象部分RefinedAbstractionA
    Abstraction *abs = new RefinedAbstraction(imp);
    abs->Operation();
    
    cout << "-----------------------------------------" << endl;
    AbstractionImp* imp2 = new ConcreteAbstractionImpB();
    Abstraction *abs2 = new RefinedAbstraction(imp2);
    abs2->Operation();
    
    delete abs;
    delete imp;
    delete abs2;
    delete imp2;
    return 0;
}

（6）makefile：

CFLAGS = -g
DEFINED = #-D _VERSION
LIBS = 
CC = g++
INCLUDES = -I./
OBJS= main.o abstraction.o abstractionimp.o
TARGET= main
all:$(TARGET)

$(TARGET):$(OBJS)
	$(CC) $(CFLAGS) -o $@ $(OBJS)

.SUFFIXES:.o .h
.SUFFIXES:.cpp .o
.cpp.o:
	$(CC) $(DEFINED) -c $(CFLAGS) -o $@ $<

ok:
	./$(TARGET)
clean:
	rm -f $(OBJS) $(TARGET) core *.log

2、运行结果

（Centos6.3系统中运行结果：）

三、总结

（1）GoF 在说明 Bridge 模式时，在意图中指出 Bridge 模式“将抽象部分与它的实现部分分离，使得它们可以独立地变化”。这句话很简单，但是也很复杂，连 Bruce Eckel 在他的大作《Thinking in Patterns》中说“Bridge 模式是 GoF 所讲述得最不好(Poorly-described)的模式”。原因就在于 GoF 的那句话中的“实现”该怎么去理解：“实现”特别是和“抽象”放在一起的时候，我们“默认”的理解是“实现”就是“抽象”的具体子类的实现，但是这里 GoF 所谓的“实现”的含义不是指抽象基类的具体子类对抽象基类中虚函数(接口)的实现，是和继承结合在一起的。而这里的“实现”的含义指的是怎么去实现用户的需求,并且指的是通过组合(委托)的方式实现的,因此这里的实现不是指的继承基类、实现基类接口,而是指的是通过对象组合实现用户的需求。理解了这一点也就理解了Bridge 模式，理解了 Bridge 模式。

（2）Bridge的实现方式其实和Builde十分的相近，可以这么说：本质上是一样的，只是封装的东西不一样罢了。两者的实现都有如下的共同点：1、都抽象出来一个基类，这个基类里面定义了共有的一些行为，形成接口函数（对接口编程而不是对实现编程），这个接口函数在Buildier中是BuildePart函数在Bridge中是Operation函数。2、都聚合一个基类的指针，如Builder模式中Director类聚合了一个Builder基类的指针，Brige模式中Abstraction类聚合了一个AbstractionImp基类的指针（优先采用聚合而不是继承）。3、都把对这个类的使用封装在一个函数中，在Bridge中是封装在Director::Construct函数中，因为装配不同部分的过程是一致的，在Bridge模式中则是封装在Abstraction::Operation函数中，在这个函数中调用对应的AbstractionImplmp::Operation函数。就两个模式而言，Builder封装了不同的生成组成部分的方式，Bridge封装了不同的实现方式。

（3）源码已经打包上传到csdn上可登录下载（http://download.csdn.net/detail/taiyang1987912/8409223）。