C++设计模式——桥接模式

前言：最近在看面向对象程序设计时，遇到了几个新鲜的设计模式于是查了查资料，最终把他搞明白了，还是很开心的。。。

桥接模式

桥接模式的定义是这样的：

1、GOF四人帮在《设计模式:可复用面向对象软件的基础》一书中是这样描述的（见下引用），现在听起来感觉云里雾里的，不要在这里纠结，我们接着往下。

将抽象部分和它的实现部分分离，使它们都可以独立的变化。简单粗暴的说，就是抽象对外提供调用的接口；对外隐瞒实现部分，在抽象中引用实现部分，从而实现抽象对实现部分的调用，而抽象中引用的实现部分可以在今后的开发过程中，切换成别的实现部分（《设计模式:可复用面向对象软件的基础》）

---

2、《大话设计模式》一书中是这样描述的（见下引用）

将抽象部分与他的实现部分分离，使他们都可以独立的变化（《大话设计模式》）

UML类图

实例

1、绘制红色的长方形、白色的圆形（Jelly Young：C++设计模式——桥接模式）

/*** FileName     : BridgePatternDemo** Author       : Jelly Young** Date         : 2013/12/4** Description  : More information （http://www.jellythink.com/）** Author       : Aidan Dai** Date         : 2015/11/20** Description  : 添加注释（http://www.jellythink.com/archives/132）*/#include <iostream>using namespace std;/***  实现（颜料）*/class Implementor{public:    virtual void OperationImpl() = 0;};/***  具体实现（黄色颜料、绿色颜料、蓝色颜料）*/class ConcreteImpementor : public Implementor{public:    void OperationImpl()    {        cout << "OperationImpl" << endl;    }};/***  抽象（平面图形）**  维护一个指向具体实现的指针（黄色颜料、绿色颜料、蓝色颜料）*/class Abstraction{public:    Abstraction(Implementor *pImpl) : m_pImpl(pImpl){}    virtual void Operation() = 0;protected:    Implementor *m_pImpl;};/***  被提炼的抽象（圆形、正方形、长方形）*/class RedfinedAbstraction : public Abstraction{public:    RedfinedAbstraction(Implementor *pImpl) : Abstraction(pImpl){}    void Operation()    {        m_pImpl->OperationImpl();    }};int main(void){    Implementor *pImplObj = new ConcreteImpementor();    Abstraction *pAbsObj = new RedfinedAbstraction(pImplObj);    pAbsObj->Operation();    delete pImplObj;    pImplObj = NULL;    delete pAbsObj;    pAbsObj = NULL;    return 0;}

2、手机软件何时统一（《大话设计模式》）

#include <iostream>#include <string>using namespace std;class Implementor{public:    void virtual Operation() = 0;};class ConcreteImplementorA : public Implementor{public:    void Operation(){        cout << "ConcreteImplementorA" << endl;    }};class ConcreteImplementorB : public Implementor{public:    void Operation(){        cout << "ConcreteImplementorB" << endl;    }};class Abstraction{public:    void SetImplementor(Implementor *implementor){        this->m_implementor = implementor;    }    void virtual Operator() = 0;protected:    Implementor *m_implementor;};class RefinedAbstraction : public Abstraction{public:    void Operator(){        this->m_implementor->Operation();    }};int main(void){    Abstraction *abstraction = new RefinedAbstraction();    Implementor *implementor1 = new ConcreteImplementorA();    abstraction->SetImplementor(implementor1);    abstraction->Operator();    Implementor *implementor2 = new ConcreteImplementorB();    abstraction->SetImplementor(implementor2);    abstraction->Operator();    delete abstraction;    abstraction = NULL;    delete implementor1;    implementor1 = NULL;    delete implementor2;    implementor2 = NULL;    return 0;}

3、自由切换家用电器开关（我给媳妇解释设计模式：第一部分（译文））

#include <iostream>#include <string>using namespace std;class Equipment{public:    void virtual poweron(string switchName) = 0;    void virtual poweroff(string switchName) = 0;};class Fan :public Equipment{public:    void poweron(string switchName){        cout << "poweron Fan by " << switchName << endl;    }    void poweroff(string switchName){        cout << "poweroff Fan by " << switchName << endl;    }};class Light :public Equipment{public:    void poweron(string switchName){        cout << "poweron Light by " << switchName << endl;    }    void poweroff(string switchName){        cout << "poweroff Light by " << switchName << endl;    }};class Switch{public:    Switch(Equipment *equipment){        this->m_equipment = equipment;    }    void virtual on() = 0;    void virtual off() = 0;    Equipment *m_equipment;};class NormalSwitch :public Switch{public:    NormalSwitch(Equipment *equipment) :Switch(equipment){        this->m_switchName = "NormalSwitch";    }    void on(){        this->m_equipment->poweron(this->m_switchName);    }    void off(){        this->m_equipment->poweroff(this->m_switchName);    }private:    string m_switchName;};class FancySwitch :public Switch{public:    FancySwitch(Equipment *equipment) :Switch(equipment){        this->m_switchName = "FancySwitch";    }    void on(){        this->m_equipment->poweron(this->m_switchName);    }    void off(){        this->m_equipment->poweroff(this->m_switchName);    }private:    string m_switchName;};int main(void){    Equipment *equipment1 = new Fan();    Equipment *equipment2 = new Light();    Switch *equipmentSwitch1 = new NormalSwitch(equipment1);    Switch *equipmentSwitch2 = new FancySwitch(equipment2);    Switch *equipmentSwitch3 = new NormalSwitch(equipment1);    Switch *equipmentSwitch4 = new FancySwitch(equipment2);    equipmentSwitch1->on();    equipmentSwitch1->off();    equipmentSwitch2->on();    equipmentSwitch2->off();    equipmentSwitch3->on();    equipmentSwitch3->off();    equipmentSwitch4->on();    equipmentSwitch4->off();    delete equipment1;    equipment1 = NULL;    delete equipment2;    equipment2 = NULL;    delete equipmentSwitch1;    delete equipmentSwitch2;    delete equipmentSwitch3;    delete equipmentSwitch4;    equipmentSwitch1 = NULL;    equipmentSwitch2 = NULL;    equipmentSwitch3 = NULL;    equipmentSwitch4 = NULL;    return 0;}

总结

is a 和 has a

1、理解继承：

• 对象的继承关系是在编译时就定义好了，所以无法再无法再运行时改变从父类继承的实现。子类的实现与它的父类有非常紧密的的依赖关系，以至于父类的实现中的任何变化必然会导致子类发生变化。当你需要复用子类时，如果继承下来的实现不适合解决新的问题，则父类必须重写或被其他更适合的类替换。这种依赖关系限制了灵活性并最终限制了复用性。

2、理解合成/聚合复用原则

• 合成/聚合复用原则：聚合表示一种弱的“拥有”关系，体现的是A对象可以包含B对象，但B对象不是A对象的一部分；合成则是一种强的“拥有”关系，体现了严格的部分和整体的关系，部分和整体的生命周期是一样的[DRE]。

就像大雁、翅膀和雁群的关系：

3、降低代码耦合度

4、通过实例不断的运用

结束语：

梦想还是要有的，万一实现了了呢！