tank.h
#ifndef _TANK_H_ #define _TANK_H_ class TankImpl; class Tank { public: virtual ~Tank(); virtual void shot()=0; virtual void run()=0; protected: Tank(); }; class ChinaTank:public Tank { public: ChinaTank(TankImpl* ti); ~ChinaTank(); void shot(); void run(); private: TankImpl* _ti; }; class JapanTank:public Tank { public: JapanTank(TankImpl* ti); ~JapanTank(); void shot(); void run(); private: TankImpl* _ti; }; #endif
tank.cpp
#include <iostream> #include "tank.h" #include "tankimplement.h" using namespace std; Tank::Tank() {} Tank::~Tank() {} // about ChinaTank ChinaTank::ChinaTank(TankImpl* tank_impl) { m_tank_impl = tank_impl; cout<<"ChinaTank constructor."<<endl; } ChinaTank::~ChinaTank() { cout<<"ChinaTank destructor."<<endl; } void ChinaTank::shot() { m_tank_impl->shot(); } void ChinaTank::run() { m_tank_impl->run(); } // about JapanTank JapanTank::JapanTank(TankImpl* tank_impl) { m_tank_impl = tank_impl; cout<<"JapanTank constructor."<<endl; } JapanTank::~JapanTank() { cout<<"JapanTank destructor."<<endl; } void JapanTank::shot() { m_tank_impl->shot(); } void JapanTank::run() { m_tank_impl->run(); }
TankImplement.h
#ifndef _TANK_IMPLEMENT_ #define _TANK_IMPLEMENT_ class TankImpl { public: virtual ~TankImpl(); virtual void shot()=0; virtual void run()=0; protected: TankImpl(); }; class WindowsTankImpl:public TankImpl { public: WindowsTankImpl(); ~WindowsTankImpl(); void shot(); void run(); }; class LinuxTankImpl:public TankImpl { public: LinuxTankImpl(); ~LinuxTankImpl(); void shot(); void run(); }; #endif
TankImplement.cpp
#include <iostream> #include "tankimplement.h" using namespace std; TankImpl::TankImpl() {} TankImpl::~TankImpl() {} // abuot WindowsTankImpl WindowsTankImpl::WindowsTankImpl() { cout<<"WindowsTankImpl constructor."<<endl; } WindowsTankImpl::~WindowsTankImpl() { cout<<"WindowsTankImpl destructor."<<endl; } void WindowsTankImpl::shot() { cout<<"Windows shot()."<<endl; } void WindowsTankImpl::run() { cout<<"Windows run()."<<endl; } // abuot LinuxTankImpl LinuxTankImpl::LinuxTankImpl() { cout<<"LinuxTankImpl constructor."<<endl; } LinuxTankImpl::~LinuxTankImpl() { cout<<"LinuxTankImpl destructor."<<endl; } void LinuxTankImpl::shot() { cout<<"Linux shot()."<<endl; } void LinuxTankImpl::run() { cout<<"Linux run()."<<endl; }
main.cpp
#include <iostream> #include "tank.h" #include "tankimplement.h" using namespace std; int main() { TankImpl* win_tank_impl = new WindowsTankImpl; TankImpl* linux_tank_impl = new LinuxTankImpl; Tank* tank1 = new ChinaTank(win_tank_impl); Tank* tank2 = new ChinaTank(linux_tank_impl); tank1->run(); tank1->shot(); tank2->run(); tank2->shot(); delete win_tank_impl; delete linux_tank_impl; delete tank1; delete tank2; return 0; }
Bridge模式的意义在于“将类的抽象部分和实现部分分离，使他们可以独立的变化”。这里抽象的含义并不是具体子类对抽象基类中虚函数的实现，而是指通过继承的方式来‘实现’用户的需求。例如，对于上面的程序，如果通过继承的方式来实现，那么就需要WindowsChinaTank，LinuxChinaTank，WindowsJapanTank，LinuxJapanTank这四个类。如果想在Android上运行，那么还需要通过继承的方式添加AndroidChinaTank和AndroidJapanTank这两个新类，更让人烦躁的是增加了继承关系的复杂度。如果用Bridge模式，我们只需要增加一个AndroidTankImpl就可以了，接下来就可以通过组合的方式获得我们想要的类型了。实际上Bridge模式就是通过组合的方式去实现一个功能需求。面向对象的一个重要的原则就是"Favor Composition Over Inheritance"。
