桥接模式

原文链接1
原文链接2
桥接模式是指将代码的实现部分与抽象部分进行分离使它们都可以独立地变化。将抽象(Abstraction)与实现分离，使得二者可以独立地变化。也就是说桥接模式的实现至少都需要两个抽象类与实现类，同时实现类去完成抽象类中的方法操作，同时在一个抽象类或者其对应的实现类中去维护另一个抽象类与实现类的对象或者指针；以手机和操作软件为例：不同的手机品牌都需要通讯录，而如果每一个通讯里都去继承该手机品牌完成通讯录的实现需要进行很多的实现，而如果在手机品牌中维护一个通讯录的基类，则可以减少代码的编写量，使得代码的编写更为灵活；需要注意的是如果该手机的通讯录是这个手机独有的，则可以减少该模式的使用，只需要继承该手机品牌即可，并不是要完全采用该模式；
这里采用原文链接1中代码：
//手机类实现

class Abstraction
{
public:
	virtual void Operation() = 0;//定义接口，表示该类所支持的操作
	virtual ~Abstraction();
protected:
	Abstraction();
};

class RefinedAbstractionA :public Abstraction
{
public:
	RefinedAbstractionA(AbstractionImplement* imp);//构造函数
	virtual void Operation();//实现接口
	virtual ~RefinedAbstractionA();//析构函数
private:
	AbstractionImplement* _imp;//私有成员
};

class RefinedAbstractionB :public Abstraction
{
public:
	RefinedAbstractionB(AbstractionImplement* imp);//构造函数
	virtual void Operation();//实现接口
	virtual ~RefinedAbstractionB();//析构函数
private:
	AbstractionImplement* _imp;//私有成员
};

#include "stdafx.h"
#include "Abstraction.h"
#include "AbstractImplement.h"
#include <iostream>

using namespace std;

Abstraction::Abstraction()
{}

Abstraction::~Abstraction()
{}

RefinedAbstractionA::RefinedAbstractionA(AbstractionImplement* imp)
{
	this->_imp = imp;
}

RefinedAbstractionA::~RefinedAbstractionA()
{
	delete this->_imp;
	this->_imp = NULL;
}

void RefinedAbstractionA::Operation()
{
	cout << "RefinedAbstractionA::Operation" << endl;
	this->_imp->Operation();
}

RefinedAbstractionB::RefinedAbstractionB(AbstractionImplement* imp)
{
	this->_imp = imp;
}

RefinedAbstractionB::~RefinedAbstractionB()
{
	delete this->_imp;
	this->_imp = NULL;
}

void RefinedAbstractionB::Operation()
{
	cout << "RefinedAbstractionB::Operation" << endl;
	this->_imp->Operation();
}

//通讯录实现

#ifndef _ABSTRACTIONIMPLEMENT_H_
#define _ABSTRACTIONIMPLEMENT_H_

//抽象基类，定义了实现的接口
class AbstractionImplement
{
public:
	virtual void Operation() = 0;//定义操作接口
	virtual ~AbstractionImplement();
protected:
	AbstractionImplement();
};

// 继承自AbstractionImplement,是AbstractionImplement的不同实现之一
class ConcreteAbstractionImplementA :public AbstractionImplement
{
public:
	ConcreteAbstractionImplementA();
	void Operation();//实现操作
	~ConcreteAbstractionImplementA();
protected:
};

// 继承自AbstractionImplement,是AbstractionImplement的不同实现之一
class ConcreteAbstractionImplementB :public AbstractionImplement
{
public:
	ConcreteAbstractionImplementB();
	void Operation();//实现操作
	~ConcreteAbstractionImplementB();
protected:
};
#endif

#include "stdafx.h"
#include "AbstractImplement.h"
#include <iostream>

using namespace std;

AbstractionImplement::AbstractionImplement()
{}

AbstractionImplement::~AbstractionImplement()
{}

ConcreteAbstractionImplementA::ConcreteAbstractionImplementA()
{}

ConcreteAbstractionImplementA::~ConcreteAbstractionImplementA()
{}

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

ConcreteAbstractionImplementB::ConcreteAbstractionImplementB()
{}

ConcreteAbstractionImplementB::~ConcreteAbstractionImplementB()
{}

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

调用方式：

// QiaoJieModels.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include "AbstractImplement.h"
#include "Abstraction.h"

#include <iostream>

using namespace std;

int main()
{
	/* 将抽象部分与它的实现部分分离，使得它们可以独立地变化

	1、抽象Abstraction与实现AbstractionImplement分离;

	2、抽象部分Abstraction可以变化，如new RefinedAbstractionA(imp)、new RefinedAbstractionB(imp2);

	3、实现部分AbstractionImplement也可以变化，如new ConcreteAbstractionImplementA()、new ConcreteAbstractionImplementB();

	*/

	AbstractionImplement* imp = new ConcreteAbstractionImplementA();        //实现部分ConcreteAbstractionImplementA
	Abstraction* abs = new RefinedAbstractionA(imp);                        //抽象部分RefinedAbstractionA
	abs->Operation();

	cout << "-----------------------------------------" << endl;

	AbstractionImplement* imp1 = new ConcreteAbstractionImplementB();        //实现部分ConcreteAbstractionImplementB
	Abstraction* abs1 = new RefinedAbstractionA(imp1);                        //抽象部分RefinedAbstractionA
	abs1->Operation();

	cout << "-----------------------------------------" << endl;

	AbstractionImplement* imp2 = new ConcreteAbstractionImplementA();        //实现部分ConcreteAbstractionImplementA
	Abstraction* abs2 = new RefinedAbstractionB(imp2);                        //抽象部分RefinedAbstractionB
	abs2->Operation();

	cout << "-----------------------------------------" << endl;

	AbstractionImplement* imp3 = new ConcreteAbstractionImplementB();        //实现部分ConcreteAbstractionImplementB
	Abstraction* abs3 = new RefinedAbstractionB(imp3);                        //抽象部分RefinedAbstractionB
	abs3->Operation();

	cout << endl;
	system("pause");
	return 0;
}

通过代码可以看出，当通讯录的需求进行改变时，只需要改变通讯录的实现即可完成，而不需要去更改手机品牌，不论手机品牌如何变化，通讯录都可以适用该手机进行使用