c++设计模式之桥接模式

                                                                                             c++设计模式之桥接模式     

作用：将抽象部份与它的实现部份分离，使它们都可以独立地变化。将抽象(Abstraction)与实现(Implementation)分离，使得二者可以独立地变化。

 

                     

桥接模式就将实现与抽象分离开来，使得RefinedAbstraction依赖于抽象的实现，这样实现了依赖倒转原则，而不管左边的抽象如何变化，只要实现方法不变，右边的具体实现就不需要修改，而右边的具体实现方法发生变化，只要接口不变，左边的抽象也不需要修改。

#include<iostream>
using namespace std;
/*
桥接模式
*/




/*
实现基类
*/ 
class AbstractionImp{
public:
virtual void operation() = 0; 
virtual ~AbstractionImp(){}
};
class ConcreteAbstractionImpA:public AbstractionImp{
public:
void operation(){
cout<<" ConcreteAstractionImpA"<<endl;
}
~ConcreteAbstractionImpA(){
cout<<"ConcreteAbstractionImpA's ~"<<endl;
}
};
class ConcreteAbstractionImpB:public AbstractionImp{
public:
void operation(){
cout<<" ConcreteAstractionImpB"<<endl;
}
~ConcreteAbstractionImpB(){
cout<<"ConcreteAbstractionImpB's ~"<<endl;
}
};
/*
抽象基类
*/ 
class Abstraction{
private:
  AbstractionImp *aImp; 
public:
Abstraction(AbstractionImp *aImp){
this -> aImp = aImp; 
}
virtual void operation() = 0;
virtual ~Abstraction(){
}
void inter()
{
aImp ->operation();
} 
};
class RefindAbstraction1:public Abstraction{
public:
RefindAbstraction1(AbstractionImp * aImp):Abstraction(aImp){
}
void operation(){
     cout<<"RefindAbstraction1 is on";
 inter();
}
~RefindAbstraction1(){
cout<<"RefindAbstraction1's ~"<<endl;
}
};
class RefindAbstraction2:public Abstraction{
public:
RefindAbstraction2(AbstractionImp * aImp):Abstraction(aImp){
}
void operation(){
cout<<"RefindAbstraction2 is on";
inter();
}
~RefindAbstraction2(){
cout<<"RefindAbstraction2's ~"<<endl;
}
};
int main (void)
{
ConcreteAbstractionImpA *cAIa= new ConcreteAbstractionImpA();
Abstraction *Ra1 = new RefindAbstraction1(cAIa);
Ra1 -> operation(); 
delete cAIa;
delete Ra1; 
return 0;
}

例子：

手机品牌和软件是两个概念，不同的软件可以在不同的手机上，不同的手机可以有相同的软件，两者都具有很大的变动性。如果我们单独以手机品牌或手机软件为基类来进行继承扩展的话，无疑会使类的数目剧增并且耦合性很高

常用的场景
1.当一个对象有多个变化因素的时候，考虑依赖于抽象的实现，而不是具体的实现。如上面例子中手机品牌有2种变化因素，一个是品牌，一个是功能。

2.当多个变化因素在多个对象间共享时，考虑将这部分变化的部分抽象出来再聚合/合成进来，如上面例子中的通讯录和游戏，其实是可以共享的。

3.当我们考虑一个对象的多个变化因素可以动态变化的时候，考虑使用桥接模式，如上面例子中的手机品牌是变化的，手机的功能也是变化的，所以将他们分离出来，独立的变化。

优点
1.将实现抽离出来，再实现抽象，使得对象的具体实现依赖于抽象，满足了依赖倒转原则。

2.将可以共享的变化部分，抽离出来，减少了代码的重复信息。

3.对象的具体实现可以更加灵活，可以满足多个因素变化的要求。

缺点
1.客户必须知道选择哪一种类型的实现。

考虑装操作

系统，

有多种配置的计算机，

同样也有多款操作系统。

如何运用桥接模式呢？可以将操作系统和

计算机分别抽象出来，让它们各自发展，减少它们的耦合度。当然了，两者之间有标准的接口。

这样设计，不论是对于计算机，还是操作系统都是非常有利的。

考虑装操作系统，有多种配置的计算机，同样也有多款操作系统。如何运用桥接模式呢？可以将操作系统和计算机分别抽象出来，让它们各自发展，减少它们的耦合度。当然了，两者之间有标准的接口。这样设计，不论是对于计算机，还是操作系统都是非常有利的。

                  

#include<iostream>
using namespace std;
/*
实现基类 
*/
class Os{
public:
virtual void install_imp() = 0;
virtual ~Os (){};
};




/*
具体实现类 
*/ 
class LinuxOS:public Os{
public:
void install_imp(){
cout<<"安装linux系统！！"<<endl;
}
};
class windowsOS:public Os{
public:
void install_imp(){
cout<<"安装windows系统！！"<<endl;
}
};
class unixOS:public Os{
public:
void install_imp(){
cout<<"安装unix系统！！"<<endl;
}
};




/*
抽象基类 
*/ 
class computer{
private:
Os * os;
string name;
public:
computer(Os *os,string name){
this->os = os;
this->name = name;
}
virtual void install() = 0;
void inter(){
   cout<<name<<":";
os->install_imp();
}
};




/*
具体抽象类 
*/ 
class Applecomputer:public computer{
public:
Applecomputer(Os *os):computer(os,"Applecomputer"){} 
void install(){
inter();
}
};
class dellcomputer:public computer{
public:
dellcomputer(Os *os):computer(os,"dellcomputer"){} 
void install(){
inter();
}
};
class lenovocomputer:public computer{
public:
lenovocomputer(Os *os):computer(os,"lenovocomputer"){} 
void install(){
inter();
}
};
int main (void)
{
Os * po1 = new windowsOS();
Os * po2 = new LinuxOS();
computer * pc1 = new lenovocomputer(po1);
computer * pc2 = new dellcomputer(po2);
pc1->install();
pc2->install();
delete po1;
delete po2;
delete pc1;
delete pc2;
return 0;
} 

备注：

由于实现的方式有多种，桥接模式的核心就是把这些实现独立出来，让他们各自变化。

将抽象部分与它的实现部分分离：实现系统可能有多角度（维度）分类，每一种分类都可能变化，那么就把这种多角度分离出来让它们独立变化，减少它们之间的耦合。

在发现需要多角度去分类实现对象，而只用继承会造成大量的类增加，不能满足开放-封闭原则时，就要考虑用Bridge桥接模式了。

合成/聚合复用原则：尽量使用合成/聚合，精良不要使用类继承。
优先使用对象的合成/聚合将有助于保持每个类被封装，并被集中在单个任务上。这样类和类继承层次会保持较小规模，并且不太可能增长为不可控制的庞然大物。