这次我把适配器，代理模式，蒙面模式敲了，终于理解了这是怎么回事。C++的设计模式实际上就是软件的功能架构，她想办法处理好类与类之间的关系，让软件好用，易操作，方便修改。软件的所遵循的原则是开闭原则，意思就是开放接口，关闭修改，我们可以去扩展；说到扩展就要提及到这六个字“高内聚，低耦合”，我们尽可能的要将功能单一化，一个模块写一个功能，那么我们需要改哪一个功能只需要找到相应就可以，这样做也容易扩展，我增一个功能进来也很easy，举个例子来说吧，假如说一个汽车，我们把汽车可以分为多个模块，发动机，备胎，座位。。。。。。还有很多很多，如果说我的发动机坏了，我仅仅需要把发动机打开，进行修理，而不需要看备胎，座位怎么回事，这就是低耦合，他们之间没有多大的联系，互相独立的模块，低耦合了，一定就高内聚了。其次呢，一定还要注意面向对象编程。
好了说适配器吧，这就是一个兼容模式，通过第三方类库实现软件功能。我没有的函数模块，可是你有啊，我给你钱直接把你的拿来用，就是这么简单
#include <iostream>
using namespace std;
class Adaptee{
public:
void Request(){
cout<<"我调用一下第三方类的方法"<<endl;
}
};
// 一定要先定义后使用
class Base{
public:
virtual void process()=0;
};
class Derived:public Base{
};
class Adapter:public Base{
private:
Adaptee a;
public:
void process(){
a.Request();
}
};
int main(int argc, char** argv) {
Base *pBase = new Adapter();
pBase->process();
delete pBase;
return 0;
}
运行结果演示
蒙面模式吧 感觉这就像个面子工程，把表面工作做好，她强调的仅仅是顺序问题，比如说你去餐厅吃饭，服务员肯定要安排好上菜的顺序，不可能你做在桌子上还没吃汤就端上来了， 而蒙面模式就干了个这事情。这几个模式比较简单吧，没有什么难度，反正至少要学会21中模式
这个代码就是很难扩展，这就违背了所谓的开闭原则，我每次要增加一个功能的时候，我还要打开Facade去天添加派生类的对象指针，这就有点烦了吧，孩纸，肯定不能这样做，反正事情就是由难，复杂，慢慢猜优化的。
#include <iostream>
#include<vector>
using namespace std;
class Abstractproduct{
public:
virtual void production()=0;
};
class productA:public Abstractproduct{
public:
void production(){
cout<<"productA的productionB正在运行"<<endl;
}
};
class productB:public Abstractproduct{
public:
void production(){
cout<<"productB的productionB正在运行"<<endl;
}
};
class productC:public Abstractproduct{
public:
void production(){
cout<<"productC的productionC正在运行"<<endl;
}
};
class Facade{
private:
productA *pA;
productB *pB;
productC *pC;
public:
Facade(productA *ta,productB *tb,productC *tc){
pA=ta;
pB=tb;
pC=tc;
}
void production(){
pB->production();
pC->production();
pA->production();
}
};
int main(int argc, char** argv) {
productC *pC = new productC();
productA *pA = new productA();
productB *pB = new productB();
Facade *pfc = new Facade(pA,pB,pC);
pfc->production();
delete pA;
delete pB;
delete pC;
delete pfc;
return 0;
}
我们队这个代码进行进行优化，我们增加一个vector，我们就用基类指针搞定她，你添加一个，我创建一个基类指针，最后在用一个迭代器逐个输出就好，顺序有客户端决定
#include <iostream>
#include<vector>
using namespace std;
//基类 Abstractproduct
class Abstractproduct{
public:
virtual void production()=0;
};
//派生类 productA
class productA:public Abstractproduct{
public:
void production(){
cout<<"productA的productionB正在运行"<<endl;
}
};
//派生类 productB
class productB:public Abstractproduct{
public:
void production(){
cout<<"productB的productionB正在运行"<<endl;
}
};
//派生类 productC
class productC:public Abstractproduct{
public:
void production(){
cout<<"productC的productionC正在运行"<<endl;
}
};
// 蒙面模式 只管调用的顺序
class Facade{
private:
vector<Abstractproduct *>vec;
public:
void add(Abstractproduct *t){
vec.push_back(t);
}
void production(){
vector<Abstractproduct *>::iterator it;
for(it=vec.begin();it!=vec.end();it++)
(*it)->production();
}
};
int main(int argc, char** argv) {
productC *pC = new productC();
productA *pA = new productA();
productB *pB = new productB();
Facade *pfc = new Facade();
pfc->add(pB);
pfc->add(pC);
pfc->add(pA);
pfc->production();
delete pA;
delete pB;
delete pC;
delete pfc;
return 0;
}
演示结果
第三种说代理模式吧，他仅仅是有个代理，一般而言代理很纯洁，他没有什么功能，比如，情人节我要给女朋友送花 ，可是我很忙，这个时候我们就需要代理，帮我送花，但是要记住花“实际上”我在送，而不是代理。相信有人听说过代理服务器吧，我仅仅吧一分部功能让出去，让代理完成就好。1989年南斯拉夫大使馆事件，我们4万中国人攻陷美国白宫网站，网站一上去后面一个大大的五星红旗，那种自豪，懂就好，可是人家解决服务器奔溃这件事人家还不到两分钟，我们很高兴的原来只是把人家的代理服务器功奔溃了，所以嘛，代理还是很重要滴，我在写代理的时候出现了，一个严重问题，就是严重的典型的指针问题，我的指针没有指向，只是看起来是对的而已，实际上是错的
我的错误代码，编译可以通过，但是运行直接奔溃，
<span style="font-size:18px;">#include <iostream>
using namespace std;
class Base{
public:
virtual void fun()=0;
virtual ~Base(){}
};
class Proxy:public Base{
private:
Base *pBase;
public:
void fun(){
pBase->fun();
}
~Proxy(){}
};
class Derived:public Base{
public:
void fun(){
cout<<"调用Derived的fun（）了"<<endl;
}
~Derived(){}
};
int main(int argc, char** argv) {
Proxy *pProxy;
pProxy->fun();
return 0;
}</span>
所以嘛，不要嫌麻烦么，简单和麻烦是相对的，我恶魔呢尽可能的吧客户端简单，那么里面的代码就越复杂
我吧修改之后的发上去
#include <iostream>
#include<vector>
using namespace std;
class Abstractproduct{
public:
virtual void production()=0;
};
class productA:public Abstractproduct{
public:
void production(){
cout<<"productA的productionB正在运行"<<endl;
}
};
class productB:public Abstractproduct{
public:
void production(){
cout<<"productB的productionB正在运行"<<endl;
}
};
class productC:public Abstractproduct{
public:
void production(){
cout<<"productC的productionC正在运行"<<endl;
}
};
class Facade{
private:
productA *pA;
productB *pB;
productC *pC;
public:
Facade(productA *ta,productB *tb,productC *tc){
pA=ta;
pB=tb;
pC=tc;
}
void production(){
pB->production();
pC->production();
pA->production();
}
};
int main(int argc, char** argv) {
productC *pC = new productC();
productA *pA = new productA();
productB *pB = new productB();
Facade *pfc = new Facade(pA,pB,pC);
pfc->production();
delete pA;
delete pB;
delete pC;
delete pfc;
return 0;
}
原文：http://blog.csdn.net/lotluck/article/details/45292959