桥接模式
1 作用
当类的模型有两个或多个维度的时候，如果两个变化维度用同一个类使用继承方式实现会变得很复杂（冗余代码很多），不易于维护和扩展（继承关系是一种强耦合关系），为了降低耦合关系，提高维护性和可扩展性，可以将两个变化维度的通过两个类（abstruction、implementor类）来实现，将两个类的关系为弱耦合的关联关系，这样就可以提高程序的扩展性和可维护性。
拿汽车在路上行驶的来说。既有小汽车又有公共汽车，它们都不但能在市区中的公路上行驶，也能在高速公路上行驶。这你会发现，对于交通工具（汽车）有不同的类型，它们所行驶的环境（路）也有不同类型，在软件系统中就要适应两个方面（不同车型，不同道路）的变化，怎样实现才能应对这种变化呢？
如果使用继承关系来实现，对应的UML图为如下：
这个模型中有路和汽车两个变化维度，第一次继承是扩展路的维度、第二次继承是扩展汽车的维度，两个维度是一个cross的关系，加入有10种路，10种汽车就会要继承出10*10+10个类，数量是指数增长的，也就是说扩展性很差，并且扩展出来的代码会有很多冗余的代码。
Road.h
#include <iostream>
#ifndef __ROAD__H__
#define __ROAD__H__
using namespace std;
class Road {
public:
virtual void run() = 0;
};
class SpeedWay: public Road {
public:
void run() override {
cout<<"run on the speed way"<<endl;
}
};
class Street: public Road {
public:
void run() override {
cout<<"run on the street"<<endl;
}
};
class CarOnSpeedWay: public SpeedWay {
public:
void run() override {
cout<<"Car run on the speed way"<<endl;
}
};
class BusOnSpeedWay: public SpeedWay {
public:
void run() override {
cout<<"Bus run on the speed way"<<endl;
}
};
class CarOnStreet: public Street {
public:
void run() override {
cout<<"Car run on the Street"<<endl;
}
};
class BusOnStreet: public Street {
public:
void run() override {
cout<<"Bus run on the Street"<<endl;
}
};
#endif
test.cc
#include "Road.h"
int main() {
Road *carOnSpeedway = new CarOnSpeedWay;
Road *busOnSpeedway = new BusOnSpeedWay;
Road *carOnStreet = new CarOnStreet;
Road *busOnStreet = new BusOnStreet;
carOnSpeedway->run();
busOnSpeedway->run();
carOnStreet->run();
busOnStreet->run();
return 0;
}
输出：
缺点:
但是我们说这样的设计是脆弱的，仔细分析就可以发现，它还是存在很多问题，首先它在遵循开放-封闭原则的同时，违背了类的单一职责原则，即一个类只有一个引起它变化的原因，而这里引起变化的原因却有两个，即路类型的变化和汽车类型的变化；其次是重复代码会很多，不同的汽车在不同的路上行驶也会有一部分的代码是相同的；
再次是类的结构过于复杂，继承关系太多，难于维护，最后最致命的一点是扩展性太差。如果变化沿着汽车的类型和不同的道路两个方向变化，我们会看到这个类的结构会迅速的变庞大。
如果要增加一种路和车型，比如StateRoad和Moto，得到的UML图就是复杂很多。
增加了2种类型，却增加了6个类，且类型越多时，往后扩展，增加的类越多。主要原因是两个变化维度进行了cross，如果把两个维度进行独立开来，分开扩展就能实现某一个维度增加一种类型，只增加一个类，cross的操作，由用户来把握，这就要使用桥接模式。
2 实现方式
将两个变化维度分为两个基类（abstraction，implementor类中来实现），则两个类的关系为关联关系，而不是继承关系。如何将两个类关联在一起由用户的需求来选择。
同样是上面的车在路上的模型，将路定义为Abstraction类，车定位为Implementor类（也可以反过来）。对应的UML模型如下：
这个结构很清晰，方便后续的扩展和维护，如果要添加一种新的类型，只需要添加一个类即可完成。
3 C++代码
Road.h
#include <iostream>
#ifndef __CAR__H__
#define __CAR__H__
using namespace std;
class AbstractCar {
public:
virtual void run () = 0;
};
class Car:public AbstractCar {
public:
void run () override {
cout<<"Car";
}
};
class Bus:public AbstractCar {
public:
void run () override {
cout<<"Bus";
}
};
class Moto:public AbstractCar {
public:
void run () override {
cout<<"Moto";
}
};
#endif
Car.h
#include <iostream>
#include "Car.h"
#ifndef __ROAD__H__
#define __ROAD__H__
using namespace std;
class AbstractRoad {
public:
AbstractRoad(AbstractCar *car):car(car){}
virtual void run() = 0;
protected:
AbstractCar *car; // 为了使用多态性，必须使用指针或者引用。
};
class SpeedWay: public AbstractRoad {
public:
SpeedWay(AbstractCar *car):AbstractRoad(car){} // 子类的构造函数调用父类的构造函数来初始父类的成员
void run() {
car->run();
cout<<" run on the speed way"<<endl;
}
};
class Street: public AbstractRoad {
public:
Street(AbstractCar *car):AbstractRoad(car){}
void run() {
car->run();
cout<<" run on the street"<<endl;
}
};
class StateRoad: public AbstractRoad {
public:
StateRoad(AbstractCar *car):AbstractRoad(car){}
void run() {
car->run();
cout<<" run on the state road"<<endl;
}
};
#endif
test.cc
#include "Car.h"
#include "Road.h"
int main() {
// 用户选择两个变化维度的组合。
AbstractRoad *carOnSpeedway = new SpeedWay(new Car);
AbstractRoad *busOnSpeedway = new SpeedWay(new Bus);
AbstractRoad *motoOnSpeedway = new SpeedWay(new Moto);
AbstractRoad *carOnStreet = new Street(new Car);
AbstractRoad *busOnStreet = new Street(new Bus);
AbstractRoad *motoOnStreet = new Street(new Moto);
AbstractRoad *carOnStateRoad = new StateRoad(new Car);
AbstractRoad *busOnStateRoad = new StateRoad(new Bus);
AbstractRoad *motoOnStateRoad = new StateRoad(new Moto);
carOnSpeedway ->run();
busOnSpeedway ->run();
motoOnSpeedway ->run();
carOnStreet ->run();
busOnStreet ->run();
motoOnStreet ->run();
carOnStateRoad ->run();
busOnStateRoad ->run();
motoOnStateRoad ->run();
return 0;
}
输出：
