【设计模式】工厂模式 C++ 创建型模式

简单工厂模式

简单工厂模式其实不难理解，我们有一间食品工厂，工厂的流水线用来生产各种口味的薯片。根据市场的要求，流水线需要随时切换生产的口味。

那么问题来了。假设不使用任何设计模式，那么我们应该怎么做？

假设不使用任何设计模式，那么我们是不是应该将各种口味的薯片各自封装成一个函数，然后根据不同的需求调用不同的函数？要调用不同的函数，那么我们必须要知道代表口味的函数名称。如果有成百上千中口味呢？

所有，简单工厂就我个人的理解来说，就是用来统一接口的。

它有两个主要的类，一个是产品类，这是一个接口类；二是一个工厂类，用来创建相应的对象。同时，还有许许多多的具体产品类，它们继承产品类，重载产品类的方法，在工厂类中根据需要生产实例。

#include<iostream>
using namespace std;
/* 产品类 */
class AbstractProduct{
	public:
		virtual void GetName() = 0;
};

/* 具体产品类A */
class ProductA:public AbstractProduct{
	public:
		void GetName(){
			cout << "This is ProductA" << endl;
		}
};

/* 具体产品类B */
class ProductB:public AbstractProduct{
	public:
		void GetName(){
			cout << "This is ProductB" << endl;
		}
};

/* 工厂类 */
class Factory{
	public:
		AbstractProduct* GetProduct(int type){
			AbstractProduct *product;
            /* 通过声明一个指向基类的指针来指向实际的子类实现，达到了多态的目的。 */
			switch(type){
				case 1:product = new ProductA();break;
				case 2:product = new ProductB();break;
				default:product = NULL;break;
			}
			return product;
		}
};

int main(){
	Factory *factory = new Factory();
	AbstractProduct *product = factory->GetProduct(2);
	product->GetName(); 
	return 0;
}

工厂方法模式

工厂方法模式跟简单工厂模式的区别主要是：一个工厂方法类生成许多具体工厂类，每个具体工厂类只生产一个 具体产品

#include<iostream>
using namespace std;

 class AbstractProduct{
 	public:
 		virtual void GetName() = 0;
 };
 
 class AbstractFactory{
 	public:
		virtual AbstractProduct* GetProduct() = 0; 
 }; 
 
 class ProductA : public AbstractProduct{
 	public:
 		void GetName(){
 			cout << "This is ProductA" << endl;
		 }
 };

 class ProductB : public AbstractProduct{
 	public:
 		void GetName(){
 			cout << "This is ProductB" << endl;
		 }
 };
 
 class FactoryA : public AbstractFactory{
 	public:
 		AbstractProduct* GetProduct(){
 			return new ProductA();
		 }
 };
 
  class FactoryB : public AbstractFactory{
 	public:
 		AbstractProduct* GetProduct(){
 			return new ProductB();
		 }
 };
 
 int main(){
 	AbstractFactory *factory = new FactoryA();
 	AbstractProduct *product = factory->GetProduct();
 	product->GetName();
 	
 	FactoryB *factory_b = new FactoryB();
 	factory_b->GetProduct()->GetName();
 	return 0;
 }
 

抽象工厂模式

抽象工厂模式跟工厂方法模式类似，从代码上而言，区别在于抽象类中接口的个数。

#include<iostream>
using namespace std;

 class AbstractProduct{
 	public:
 		virtual void GetName() = 0;
 };
 
 class AbstractFactory{
 	public:
		virtual AbstractProduct* GetProduct() = 0; 
 }; 
 
 class ProductA : public AbstractProduct{
 	public:
 		void GetName(){
 			cout << "This is ProductA" << endl;
		 }
 };

 class ProductB : public AbstractProduct{
 	public:
 		void GetName(){
 			cout << "This is ProductB" << endl;
		 }
 };
 
 class FactoryA : public AbstractFactory{
 	public:
 		AbstractProduct* GetProduct(){
 			return new ProductA();
		 }
 };
 
  class FactoryB : public AbstractFactory{
 	public:
 		AbstractProduct* GetProduct(){
 			return new ProductB();
		 }
 };
 
 int main(){
 	AbstractFactory *factory = new FactoryA();
 	AbstractProduct *product = factory->GetProduct();
 	product->GetName();
 	
 	FactoryB *factory_b = new FactoryB();
 	factory_b->GetProduct()->GetName();
 	return 0;
 }