Bridge模式学习

     设计模式是个很high的东东啊，话说，C就没有这东东，的确，都没法多态继承什么的，不好谈抽象啊。昨天老大小讲座，讲了下Bridge模式，其UML图如下：

         图来自：http://blog.sina.com.cn/s/blog_40bfcb680100ctmq.html（也是篇不错的讲述，虽然是用Java，不过思路还是很清楚，主要也是怎么组合）

        大体来说，Bridge是把行为与数据分开，如同，我有一个抽象类Abstract，如果直接采用继承的方式，则每个子类将会拥有比Abstract大的空间，当抽象类的数据很多时，会造成空间的极大浪费。如果我们将其中的行为分离出来，用一个抽象类Implementor表示，Abstract中有一个Implementor指针，则为聚合关系，再用Implementor的子类去实现行为，则能很省空间。

       大体的C++实现如下：

/*
 * Bridge.h
 * Created on: Oct 17, 2011
 * Author: xia
 */

#ifndef BRIDGE_H_
#define BRIDGE_H_

#include <iostream>
using namespace std;

class Implement {

public:
	Implement();
	virtual ~Implement();

	virtual void operate();
	virtual void getCata();
	virtual void getSex();
	virtual void getGrade();

};

class HumanOperate:public Implement {

public:
	HumanOperate() ;
	virtual ~HumanOperate() ;
	void operate();
	void getCata();
	void getSex();
	void getGrade();
};

class AnimalOperate:public Implement {

public:
	AnimalOperate();
	virtual ~AnimalOperate();
	void operate();
};

class FishOperate:public Implement {

public:
	FishOperate();
	virtual ~FishOperate();
	void operate();
};

class Abstract {

private:
	int    cata;
	int    name;
	int    age;
	int    sex;
	int    grade;
	int    add;
	bool   charm;
	float  height;
	double weight;

	Implement *m_pimp;

public:
	Abstract();
	Abstract(Implement *);
	virtual ~Abstract();
	virtual void getCata() = 0;
	virtual void getSex() = 0;
	virtual void getGrade() = 0;
	Implement* getImp(){
		return m_pimp;
	}
	void setImp(Implement* input) {
		m_pimp = input;
	}

};

class Test {

private:
	Implement* m_pimp;

public:
	Test(Implement *input) {
		m_pimp = input ;
	}
	Implement* getImp() {
		return m_pimp;
	}
	void say() {
		cout << "Test says : hello world " << endl;
	}
};

#endif /* BRIDGE_H_ */

Bridge.cpp

/*
 * Bridge.cpp
 * Created on: Oct 17, 2011
 * Author: xia
 */

#include "Bridge.h"

Abstract::Abstract() {

}
Abstract::Abstract( Implement *input) {
	m_pimp = input;
}
Abstract::~Abstract() {
	if (m_pimp != NULL)
	{
		delete m_pimp;
		m_pimp = NULL;
	}
}

Implement::Implement() {
	cout <<"Implement constructor" << endl;
}
Implement::~Implement() {
	cout <<"Implement destructor" << endl;
}
void Implement::operate() {

}
void Implement::getCata() {

}
void Implement::getSex() {

}
void Implement::getGrade() {

}

HumanOperate::HumanOperate() {

}
HumanOperate::~HumanOperate() {

}
void HumanOperate::operate() {
	cout << "Human  operate " << endl;
}

void HumanOperate::getSex() {

}
void HumanOperate::getCata() {

}
void HumanOperate::getGrade() {

}

AnimalOperate::AnimalOperate() {

}
AnimalOperate::~AnimalOperate() {

}
void AnimalOperate::operate() {
	cout << "Animal  operate " << endl;
}

FishOperate::FishOperate() {

}
FishOperate::~FishOperate() {

}
void FishOperate::operate() {
	cout << "Fish  operate " << endl;
}

test.cpp

//============================================================================
// Name        : Test.cpp
// Author      : xia
// Version     : 1.0
// Copyright   : NUAA
// Description : Hello World in C++, Ansi-style
//============================================================================

#include "Bridge.h"

int main() {
	Implement *imp = new FishOperate();
	Test someOne(imp);
	someOne.getImp()->operate();
	return 0;
}

       不过楼主的这个程序的一个问题是Test类不是Abstract的子类，所以没有实现常用的组合功能，只是在main中仅仅在一处修改生成对象，达到调用不同方法的目标，即仅仅是描述了分离数据与实现。

         对于Bridge模式，http://topic.csdn.net/t/20061216/19/5235617.html 里面有个不错的实现了组合的代码；另外，9楼的类比也很不错：

   “BRIDGE—早上碰到MM，要说早上好，晚上碰到MM，要说晚上好；碰到MM穿了件新衣服，要说你的衣服好漂亮哦，碰到MM新做的发型，要说你的头发好漂亮哦。不要问我“早上碰到MM新做了个发型怎么说”这种问题，自己用BRIDGE组合一下不就行了   ”
　　 
　  桥梁模式：将抽象化与实现化脱耦，使得二者可以独立的变化，也就是说将他们之间的强关联变成弱关联，也就是指在一个软件系统的抽象化和实现化之间使用组合/聚合关系而不是继承关系，从而使两者可以独立的变化。

          继续学习ing