桥梁模式,将抽象部分与它的实现部分分离,使它们都可以独立地变化。实现分离的办法就是增加一个类,
#include <iostream>
using namespace std;
class AbstractionImp
{
public:
virtual ~AbstractionImp(){}
virtual void Operation(){}
protected:
AbstractionImp()
{
cout <<"AbstractionImp "<< endl;
}
};
class Abstraction
{
public:
virtual void Operation()=0;
virtual ~Abstraction(){}
protected:
Abstraction(){}
};
class RefinedAbstraction :public Abstraction
{
public:
RefinedAbstraction(AbstractionImp *imp)
{
_imp = imp;
}
~RefinedAbstraction(){}
void Operation()
{
_imp->Operation();
}
private:
AbstractionImp *_imp;
};
class ConcreteAbstractionImpA:public AbstractionImp
{
public:
ConcreteAbstractionImpA(){}
~ConcreteAbstractionImpA(){}
virtual void Operation()
{
cout << "ConcreteAbstractionImpA"<< endl;
}
};
class ConcreteAbstractionImpB:public AbstractionImp
{
public:
ConcreteAbstractionImpB()
{
cout<<"ConcreteAbstractionImB...."<<endl;
}
~ConcreteAbstractionImpB(){}
virtual void Operation()
{
}
};
int main()
{
AbstractionImp* imp = new ConcreteAbstractionImpA();
Abstraction* abs = new RefinedAbstraction(imp);
abs->Operation();
return 0;
}
//操作系统
class IOS
{
public:
IOS(){}
virtual ~IOS(){}
virtual void Run()=0;
};
class CWindows : public IOS
{
public:
CWindows(){}
virtual ~CWindows(){}
virtual void Run()
{
TRACE("[Window OS]!\n");
}
};
class CLinux : public IOS
{
public:
CLinux(){}
virtual ~CLinux(){}
virtual void Run()
{
TRACE("[Linux OS]!\n");
}
};
//电脑品牌
class ICompute
{
public:
ICompute(){}
virtual ~ICompute(){}
virtual void Install(IOS* pOS)=0;
};
class CIBM : public ICompute
{
public:
CIBM(){}
virtual ~CIBM(){}
virtual void Install(IOS* pOS)
{
TRACE("IBM compute install ");
pOS->Run();
}
};
class CHP : public ICompute
{
public:
CHP(){}
virtual ~CHP(){}
virtual void Install(IOS* pOS)
{
TRACE("HP compute install ");
pOS->Run();
}
};
int main()
{
IOS* pW = new CWindows();
IOS* pL = new CLinux();
ICompute* pIBM = new CIBM();
pIBM->Install(pW);
pIBM->Install(pL);
return 0;
}