Bridge模式

 

//AbstractionImp.h

#ifndef _ABSTRACTIONIMP_H

#define _ABSTRACTIONIMP_H

class AbstractionImp

{

public:

        virtual ~AbstractionImp();

        virtual void Operation();

protected:

        AbstractoinImp();

};

 

class ConcreteAbstractionImpA:AbstractionImp

{

public:

        ConcreteAbstractionImpA();

        ~ConcreteAbstractionImpA();

        virtual void Operation();

};

 

class ConcreteAbstractionImpB:AbstractionImp

{

public:

        ConcreteAbstractionImpB();

        ~ConcreteAbstractionImpB();

        virtual void Operation();

};

#endif

 

//AbstractionImp.cpp

#include "AbstractionImp.h"

#include <iostream>

using namespace std;

 

AbstractionImp::AbstractionImp()

{}

AbstractionImp::~AbstractionImp()

{}

void AbstractionImp::Operation()

{

        cout<<"AbstractionImp...Imp..."<<endl;

}

ConcreteAbstractionImpA::ConcreteAbstractionImpA()

{}

ConcreteAbstractionImpA::~ConcreteAbstractionImpA()

{}

void ConcreteAbstractionImpA::Operation()

{

        cout<<"AbstractionImp...A...Imp..."<<endl;

}

ConcreteAbstractionImpB::ConcreteAbstractionImpB()

{}

ConcreteAbstractionImpB::~ConcreteAbstractionImpB()

{}

void ConcreteAbstractionImpB::Operation()

{

        cout<<"AbstractionImp...B...Imp..."<<endl;

}

 

//Abstraction.h

#ifndef _ABSTRACTION_H

#define _ABSTRACTION_H

class AbstractonImp;

 

class Abstraction

{

public:

        virtual ~Abstraction();

        virtual void Operation() = 0;

protected:

        Abstraction();

};

 

class RefinedAbstraction:Abstraction

{

public:

        ~RefinedAbstraction();

        virtual void Operation();

        RefinedAbstraction(AbstractionImp * absp);

private:

        AbstracionImp * _absp;

};

#endif

 

//Abstraction.cpp

#include "Abstraction.h"

include "AbstractionImp.h"

#include <iostream>

using namespace std;

 

Abstraction::Abstraction()

{}

Abstraction::~Abstraction()

{}

RefinedAbstraction::RefinedAbstraction(AbstractionImp * absp)

{

        _absp = absp;

}

RefinedAbstraction::~RefinedAbstraction()

{}

void RefinedAbstraction::Operation()

{

        _absp->Operation();

}

 

//main.cpp

#include "AbstractionImp.h"

#include "Abstraction.h"

using namespace std;

 

void main(int argc, char * argv[])

{

        AbstractionImp *pA = new ConcreteAbstractionImpA();

        Abstraction *p = new RefinedAbstraction(pA);

        p->Operation();

        return 0;

}