适配器 蒙面模式 代理模式

                            这次我把适配器，代理模式，蒙面模式敲了，终于理解了这是怎么回事。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;
}

 

如果有什么问题，欢迎指正，本人菜鸟一枚