Bridge模式

Bridge模式使用组合（委托）的方式将抽象和实现彻底解耦，抽象和实现可以分别独立的变化，系统耦合性降低

abstraction.h：

#ifndef _ABSTRACTION_H_
#define _ABSTRACTION_H_

class AbstractionImp;
class Abstraction
{
public:
	virtual ~Abstraction();
	virtual void Operation() = 0;
protected:
	Abstraction();
private:
};

class RefinedAbstraction:public Abstraction
{
public:
	RefinedAbstraction(AbstractionImp* imp);
	~RefinedAbstraction();
	void Operation();
protected:
private:
	AbstractionImp* _imp;
};
#endif //~_ABSTRACTION_H

abstraction.cpp：

#include "abstraction.h"
#include "abstractionImp.h"
#include <iostream>
using namespace std;


Abstraction::Abstraction()
{

}
Abstraction::~Abstraction()
{

}

RefinedAbstraction::RefinedAbstraction(AbstractionImp* imp)
{
	_imp = imp;
}
RefinedAbstraction::~RefinedAbstraction()
{

}
void RefinedAbstraction::Operation()
{
	_imp->Operation();
}

abstractionImp.h：

//AbstractionImp.h
#ifndef _ABSTRACTIONIMP_H_
#define _ABSTRACTIONIMP_H_


class AbstractionImp
{
public:
	virtual ~AbstractionImp();
	virtual void Operation() = 0;
protected:
	AbstractionImp();
private:
};
class ConcreteAbstractionImpA:public AbstractionImp
{
public:
	ConcreteAbstractionImpA();
	~ConcreteAbstractionImpA();
	virtual void Operation();
protected:
private:
};

class ConcreteAbstractionImpB:public AbstractionImp
{
public:
	ConcreteAbstractionImpB();
	~ConcreteAbstractionImpB();
	virtual void Operation();
protected:
private:
};
#endif //~_ABSTRACTIONIMP_H_

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<<"ConcreteAbstractionImpA...."<<endl;
}


ConcreteAbstractionImpB::ConcreteAbstractionImpB()
{

}
ConcreteAbstractionImpB::~ConcreteAbstractionImpB()
{

}
void ConcreteAbstractionImpB::Operation()
{
	cout<<"ConcreteAbstractionImpB...."<<endl;
}

main.cpp：

#include "abstraction.h"
#include "abstractionImp.h"

#include <iostream>
using namespace std;


int main(){

	AbstractionImp* imp = new ConcreteAbstractionImpA();
	Abstraction* abs = new RefinedAbstraction(imp);
	abs->Operation();

	return 1;
}