设计模式之工厂模式

工厂模式

一.简单工厂模式

 

# include<iostream>
using namespace std;

class product{
	public:
		virtual void Do()=0;
}; 

class productA:public product{
	public:
		void Do(){
			cout<<"生产A"<<endl;
		}
};

class productB:public product{
	public:
		void Do(){
			cout<<"生产B"<<endl;
		}
};

class productC:public product{
	public:
		void Do(){
			cout<<"生产C"<<endl;
		}
};

class Factory{
	private:
		product*p;
		public:
			Factory(int n){
				switch(n){
					case 1:p=new productA();
					  		break;
					case 2:
						p=new productB();
						break;
					case 3:
						p=new productC();
						break;
				}
			}
			
			void send(){
				p->Do();
			}
			
			~Factory(){
				delete p;
			}
}; 

int main(void){
	Factory *factory=new Factory(2);
	factory->send();
}

以上代码好处是接口统一,但违背了开闭原则,添加一个功能就要增加一个case产品

将Factory代码改进如下

class Factory{
	private:
		product*p;
		public:
			Factory(product *t){
				p=t;
			}
			
			void send(){
				p->Do();
			}
			
			~Factory(){
				delete p;
			}
}; 

这样做将压力转向了客户端

但遵守了开闭原则

 

二.抽象工厂

让不同工厂负责不同产品

#include <iostream>
using namespace std;

class product{
	public :
	virtual void Do()=0; 
};

class productA:public product{
	public:
		void Do(){
			cout<<"生产A"<<endl;
		}
};

class productB:public product{
	public:
		void Do(){
			cout<<"生产B"<<endl;
		}
};

class productC:public product{
	public:
		void Do(){
			cout<<"生产C"<<endl;
		}
};


class Factory{
	private:
		product *p;
	public:
		Factory(product*t){
			p=t;
		}
		 void send(){
		 	p->Do();
		 }
		virtual~Factory(){
			delete p;
		}
};

class FactoryA:public Factory{
	public:
		FactoryA(product*t):Factory(t){
			
		}
	
};

class FactoryB:public Factory{
	public:
		FactoryB(product*t):Factory(t){
			
		}
	
};

class FactoryC:public Factory{
	public:
		FactoryC(product*t):Factory(t){
			
		}
	
};

int main(void){
	Factory *fa=new FactoryA(new productA());
	fa->send();
	delete fa;
}

以上代码分别让三个工厂去生产三种产品,减轻了客户端的压力,让不同的工厂分别管理 不同的产品

注:

以上代码工厂类的三个派生类都将代码实现了抽取到基类中,这样在代码量大的时候会明显体现出将相同代码抽取到基类的好处

使代码得到了复用,更加简洁.

(1)相同的构造函数,直接调用基类构造函数进行初始化

(2)send()函数完成的功能也都相似,都是调用当前工厂类指向的生产对象,并调用生产对象的Do()函数

因此可以抽取到基类中,当客户端调用时,在派生类中没找到send()方法,则直接去基类中找