c++设计模式：Factory 工厂模式详解（简单工厂、工厂方法、抽象工厂）

1.简单工厂模式

模式的结构与实现

该模式中包含的角色及其职责如下:

工厂角色：简单工厂模式的核心，它负责实现创建所有实例的内部逻辑。工厂类的创建产品类的方法可以被外界直接调用，创建所需的产品对象。
抽象产品角色：简单工厂模式所创建的所有对象的父类，它负责描述所有实例所共有的公共接口。
具体产品角色：是简单工厂模式的创建目标，所有创建的对象都是充当这个角色的某个具体类的实例。
缺点：对修改不封闭，新增加产品就需要修改工厂。违法了开闭法则（OCP）。

UML图如下：

 

代码实现：

#include<stdio.h>
using namespace std;

//定义手机类型
enum PRODUCTTYPE { OPPO, VIVO, HUAWEI };


class phoneBase
{
  public:
  virtual ~PhoneBase{} ();
  virtual void show() = 0;
};

//具体抽象oppo类
class oppoPhone:public PhoneBase
{
  public: 
  
  void show() { cout << "OPPO Phone" << endl; }
};

//具体抽象vivo类
class vivoPhone:public PhoneBase
{
  public: 
  
  void show() { cout << "vivo Phone" << endl; }
  
};

//具体抽象类
class HUAWEIPhone:public PhoneBase
{
  public: 
 
  void show() { cout << "HUAWEI Phone" << endl; }
  
};


//手机工厂
class Factory
{
  public: 
  
  /* 根据相应的类型进行生产 */
	phoneBase* createPhone(PRODUCTTYPE type)
	{
      switch(type)
       
      case:oppo
         return new oppophone();
         break;
    
      case:vivo
         return new vivophone();
         break;

      case:HUAWEI
         return new HUAWEIphone();
         break;
  
    }
  
  private: 
};

int mian()
{
  Factory factory;
  
  phoneBase* p1 = factory.createPhone(oppo);
  p1->show();
  
  phoneBase* p2 = factory.createPhone(VIVO);
  p2->show();

  phoneBase* p3 = factory.createPhone(HUAWEI);
  p3->show();
  
  delete p1;
  delete p2;
  delete p3;
  
  return 0;
}

---

2.工厂方法

模式的结构与实现

该模式中包含的角色及其职责如下:

抽象工厂角色：是工厂方法模式的核心，与应用程序无关。任何在模式中创建的对象的工厂类必须实现这个接口。
具体工厂角色：这是实现抽象工厂接口的具体工厂类，包含与应用程序密切相关的逻辑，并且受到应用程序调用以创建产品对象。
抽象产品角色：工厂方法模式所创建的对象类型，也就是产品对象的共同父类或共同拥有的接口。
具体产品角色：这个角色实现了抽象产品角色所定义的接口。某具体产品有专门的具体工厂创建，它们之间往往一一对应。
UML图如下：

重点就是：在这个模式中，工厂类和产品类往往可以依次对应。即一个抽象工厂对应一个抽象产品，一个具体工厂对应一个具体产品，这个具体的工厂就负责生产对应的产品

#include<stdio.h>
using namespace std;

//定义手机类型
enum PRODUCTTYPE { OPPO, VIVO, HUAWEI };


class phoneBase
{
  public:
  virtual ~PhoneBase{} ();
  virtual void show() = 0;
};

//具体抽象oppo类
class oppoPhone:public PhoneBase
{
  public: 
  
  void show() { cout << "OPPO Phone" << endl; }
};

//具体抽象vivo类
class vivoPhone:public PhoneBase
{
  public: 
  
  void show() { cout << "vivo Phone" << endl; }
  
};

//具体抽象类
class HUAWEIPhone:public PhoneBase
{
  public: 
 
  void show() { cout << "HUAWEI Phone" << endl; }
  
};


//手机工厂
class Factory
{
  public: 
  
  /* 提供抽象生产接口，由各个具体工厂实现 */
	virtual phoneBase* createPhone() = 0;
};

/* OPPO工厂 —— 专门负责生产OPPO手机 */
class OPPOFactory : public Factory
{
  public:
  
  phoneBase* createPhone()
  {
    return new OPPOPhone();
  }
};

/* VIVO工厂 —— 专门负责生产VIVO手机 */
class VIVOFactory : public Factory
{
public:
	phoneBase* createPhone()
	{
		return new VIVOPhone();
	}
};

/* HUAWEI工厂 —— 专门负责生产HUAWEI手机 */
class HUAWEIFactory : public Factory
{
public:
	phoneBase* createPhone()
	{
		return new HUAWEIPhone();
	}
};


int mian()
{
  OPPOFactory Ofactory;
  phoneBase* p1 = Ofactory.createPhone();
  p1->show();
  
  VIVOFactory Vfactory;
  phoneBase* p2 = Vfactory.createPhone();
  p2->show();

  HUAWEIFactory Hfactory;
  phoneBase* p3 = Hfactory.createPhone();
  p3->show();
  
  delete p1;
  delete p2;
  delete p3;
  
  return 0;
}

 

---

3.抽象工厂

模式的结构与实现

抽象工厂模式同工厂方法模式一样，也是由抽象工厂、具体工厂、抽象产品和具体产品等 4 个要素构成，但抽象工厂中方法个数不同，抽象产品的个数也不同。现在我们来分析其基本结构和实现方法。

抽象工厂模式的主要角色如下：

抽象工厂：提供了创建产品的接口，它包含多个创建产品的方法 newProduct()，可以创建多个不同等级的产品。
具体工厂：主要是实现抽象工厂中的多个抽象方法，完成具体产品的创建。
抽象产品：定义了产品的规范，描述了产品的主要特性和功能，抽象工厂模式有多个抽象产品。
具体产品：实现了抽象产品角色所定义的接口，由具体工厂来创建，它同具体工厂之间是多对一的关系。
 

UML图如下：

// 抽象工厂
#include <iostream>
using namespace std;

/* 定义手机类型 */
enum PRODUCTTYPE { OPPO, VIVO, HUAWEI };

/* 定义其他产品类型：芯片、配件 */
enum OTHERTYPE { IC, CASE }; 

/* 定义抽象产品phone */
class phoneBase
{
public:
	virtual ~phoneBase() {};
	virtual void show() = 0;
};

/* OPPO具体产品phone */
class OPPOPhone :public phoneBase
{
public:
	void show() { cout << "OPPO Phone" << endl; }
};

/* VIVO具体产品phone */
class VIVOPhone :public phoneBase
{
public:
	void show() { cout << "VIVO Phone" << endl; }
};

/* HUAWEI具体产品phone */
class HUAWEIPhone :public phoneBase
{
public:
	void show() { cout << "HUAWEI Phone" << endl; }
};

/* 定义抽象产品OTHER */
class OTHERBase
{
public:
	virtual ~OTHERBase() {};
	virtual void show() = 0;
};

/* OPPO具体产品OTHER */
class OPPOOTHER :public OTHERBase
{
public:
	void show() { cout << "OPPO OTHER PRODUCT" << endl; }
};

/* VIVO具体产品OTHER */
class VIVOOTHER :public OTHERBase
{
public:
	void show() { cout << "VIVO OTHER PRODUCT" << endl; }
};

/* HUAWEI具体产品OTHER */
class HUAWEIOTHER :public OTHERBase
{
public:
	void show() { cout << "HUAWEI OTHER PRODUCT" << endl; }
};

/* 抽象工厂 : 提供了产品的生成方法。 */
class Factory
{
public:
	virtual phoneBase* createPhone() = 0;
	virtual OTHERBase* createOther() = 0;
};

/* OPPO具体工厂：实现了OPPO产品族的生成方法。 */
class OPPOFactory : public Factory
{
public:
	phoneBase* createPhone()
	{
		return new OPPOPhone();
	}

	OTHERBase* createOther()
	{
		return new OPPOOTHER();
	}
};

/* VIVO具体工厂：实现了VIVO产品族的生成方法。 */
class VIVOFactory : public Factory
{
public:
	phoneBase* createPhone()
	{
		return new VIVOPhone();
	}

	OTHERBase* createOther()
	{
		return new VIVOOTHER();
	}
};

/* HUAWEI具体工厂：实现了HUAWEI产品族的生成方法。 */
class HUAWEIFactory : public Factory
{
public:
	phoneBase* createPhone()
	{
		return new HUAWEIPhone();
	}

	OTHERBase* createOther()
	{
		return new HUAWEIOTHER();
	}
};


int main()
{
	OPPOFactory Ofactory;
	phoneBase* p1 = Ofactory.createPhone();
	OTHERBase* p2 = Ofactory.createOther();
	p1->show();
	p2->show();

	VIVOFactory Vfactory;
	phoneBase* p3 = Vfactory.createPhone();
	OTHERBase* p4 = Vfactory.createOther();
	p3->show();
	p4->show();

	HUAWEIFactory Hfactory;
	phoneBase* p5 = Hfactory.createPhone();
	OTHERBase* p6 = Hfactory.createOther();
	p5->show();
	p6->show();

	delete p1;
	delete p2;
	delete p3;
	delete p4;
	delete p5;
	delete p6;
	return 0;
}