桥梁模式

桥梁模式，将抽象部分与它的实现部分分离，使它们都可以独立地变化。实现分离的办法就是增加一个类，

#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;
}