简单工厂模式

简单工厂模式（Simple Factory Pattern）专门定义一个类来负责创建其他类的实例，被创建的实例通常具有共同的父类。

简单工厂模式，是一种实例化对象的方式，只要输入需要实例化对象的名字，就可以通过工厂对象的相应工厂函数来制造你需要的对象。

简单工厂模式的角色

（1）Factory工厂角色（工厂类）：

工厂角色即工厂类，是简单工厂模式的核心，负责创建所有实例的内部逻辑，工厂类可以被外界直接调用，创建所需要的产品对象。

（2）Product（抽象产品角色）：

抽象产品角色是简单工厂模式所创建的所有对象的父类，负责描述所有实例所共有的公告接口。所创建的具体产品对象都是其子类对象。

（3）ConcreteProduct（具体产品角色）：

具体产品角色是简单工厂模式的创建目标。每个具体产品角色都继承了抽象产品角色，需要实现定义在抽象产品中的方法。

简单工厂的介绍

简单工厂（Simple Factory）不属于标准的OOP设计模式中的一项，在编写大型C++软件的时候，代码里面会出现很多的类，每次创建对象的时候，都需要通过new 类名称的方式来生成对象，这样一来，用户需要记忆很多类的名称，暂且不管记不记得住，这样的设计使得代码很难维护，类名如果做了改变，那么所有使用类名称的地方都需要去修改，耦合性太强，不符合我们软件设计的思想，Simple Factory就是在这样的需求下诞生的。

我们把对象的创建全部都封装在了SimpleFactory的create方法中，在这里我们传入一个Product就可以创建一个对象，省略了new的过程

#include <iostream>
#include <string>
using namespace std;
//产品类型的声明,抽象产品
class  Product
{
public:Product(string name) : ProductName(name) {};virtual void show() = 0;
protected:string ProductName;
};//具体产品的声明
class BaoMa :public Product
{
public:BaoMa(string name) : Product(name) {};void show(){std::cout << "This is BaoMa Product" << char(10);std::cout << ProductName << char(10);}
};//具体产品2 的申明
class BengChi :public Product
{
public:BengChi(string name) : Product(name) {};void show(){std::cout << "This is <BengChi> Product" << char(10);std::cout << ProductName << char(10);}
};enum ProductType
{BWM,BC
};class SimpleFactory
{
public://通过传入的枚举类型，创建对应的对象，返回对象的基类指针Product* createProduct(ProductType type){switch (type){case BWM:return new BaoMa("宝马");break;case BC:return new BengChi("奔驰");break;default:std::cout << "你输入了错误的名字" << type << char(10);break;}}
};int main()
{//创建简单工厂的实例SimpleFactory sf;unique_ptr<Product> p1(sf.createProduct(BWM));unique_ptr<Product> p2(sf.createProduct(BC));p1->show();p2->show();return 0;
}

工厂方法

UML图片

通过产生具体的工厂创建具体的产品，做到了在扩充新产品时，能够达到软件设计的“开-闭”原则

代码

#include <iostream>
#include <string>
using namespace std;class AbstractProduct
{
public:AbstractProduct(string name): _name(name){}//模拟产品对象的抽象方法virtual void show() = 0;
protected:string _name;
};class ProductA:public AbstractProduct
{
public://其实这是一个委托构造函数ProductA(string name) : AbstractProduct(name) {}void show() { std::cout << "这是一个产品A的对象"; char(10);std::cout << "string name : " << _name << char(10);}
};class ProductB :public AbstractProduct
{
public://其实这是一个委托构造函数ProductB(string name) : AbstractProduct(name) {}void show() { std::cout << "这是一个产品B的对象"<< char(10);std::cout << "string name : " << _name << char(10);}
};//定义枚举类型的数据
enum  ProductType
{XIAOMI,HUAWEI,
};//定义抽象工厂
class AbstractFactory
{
public:virtual AbstractProduct* createProduct() = 0;
};//小米手机工厂
class XiaoMiFactory:public AbstractFactory
{
public:AbstractProduct* createProduct(){std::cout << "调用了小米工厂的创建方法" << char(10);return new ProductA("小米手机");}
};//华为手机工厂
class HuaWeiFactory :public AbstractFactory
{
public:AbstractProduct* createProduct(){std::cout << "调用了华为工厂的创建方法" << char(10);return new ProductB("华为手机");}
};int main()
{//在这里我们使用智能指针,创建具体工厂unique_ptr<AbstractFactory> Fac1(new XiaoMiFactory);unique_ptr<AbstractFactory> Fac2(new HuaWeiFactory);//通过工厂方法创建产品unique_ptr<AbstractProduct> Pro1(Fac1->createProduct());unique_ptr<AbstractProduct> Pro2(Fac2->createProduct());Pro1->show();Pro2->show();return 0;
}

工厂方法可以解决一簇产品（一款产品有多种形态）的问题，并且工厂一次只能生产一种产品；但需要一个工厂能够同时生产多款产品时，则需要用到抽象工厂模式

工厂方法总结：

仔细理解上面的工厂方法模式，会发现一个问题，就是每一个实例工厂负责生产一个实例产品，也就是一个产品对应一个工厂，一个工厂对应一个产品，那么小米不仅仅生产手机，还生产耳机，智能手环，智能插座等等相关的小米产品簇，不可能给这每一个产品都创建一个工厂类，那样的话代码中的类就太多了，不好维护，而且也不符合实际情况。

实际上小米或者华为的工厂里面，有相关联的产品簇都是在一个工厂完成创建的；BMW或者Audi汽车制造工厂除了生产汽车，生产线上也有可能生产轮胎，或者其它的汽车附属产品。

所以对于包含产品簇这么一类实体关系的设计，就需要使用Abstract Factory抽象工厂了，你也可以把上面的工厂方法看作只生产一种产品的抽象工厂，本质是相同的。

抽象工厂

可以看到，抽象工厂模式把一个产品簇的产品放在一个工厂类中去创建，不仅大大减少了工厂类的个数，更符合现实中工厂生产产品的模式。根据上面的内容描述，仔细思考简单工厂，工厂方法和抽象工厂的区别联系。

代码实现

#include <iostream>
using namespace std;//抽象产品 手机类
class AbstractPhone
{
public:AbstractPhone(string name) : _name(name) {};//模拟产品对象的一个抽象的方法virtual void show() = 0; 
protected:string _name;
};//产品实体类型 小米
class XiaoMiPhone: public AbstractPhone
{
public:XiaoMiPhone(string name) : AbstractPhone(name) {};void show(){std::cout << "这是" << _name << "手机" << char(10);}
};//产品实体类型 华为
class HuaweiPhone : public AbstractPhone
{
public:HuaweiPhone(string name) : AbstractPhone(name) {};void show(){std::cout << "这是" << _name << "手机" << char(10);}
};//抽象产品 手环
class AbstractCircle
{
public:AbstractCircle(string name) : _name(name) {};//模拟产品对象的一个抽象的方法virtual void show() = 0;
protected:string _name;
};//产品实体 小米手环
class  XiaoMiCircle:public AbstractCircle
{
public:XiaoMiCircle(string name) :AbstractCircle(name) {};void show(){std::cout << "这是" << _name << "手环" << char(10);}
};//产品实体 华为手环
class  HuaWeiCircle :public AbstractCircle
{
public:HuaWeiCircle(string name) :AbstractCircle(name) {};void show(){std::cout << "这是" << _name << "手环" << char(10);}
};//抽象工厂，创建一个产品族的设备的产品
class AbstractFactory
{
public://创建手机的纯虚函数virtual AbstractPhone* createPhone() = 0;virtual AbstractCircle* createCircle() = 0;
};//生产小米的工厂
class XiaoMiFactory:public AbstractFactory
{
public:virtual AbstractPhone* createPhone(){return new XiaoMiPhone("小米14Pro");}virtual AbstractCircle* createCircle(){return new XiaoMiCircle("小米手环NFC版本");}
};//生产华为的工厂
class HuaWeiFactory :public AbstractFactory
{
public:virtual AbstractPhone* createPhone(){return new XiaoMiPhone("华为Mate60 pro");}virtual AbstractCircle* createCircle(){return new XiaoMiCircle("华为GT Runing");}
};int main()
{//利用智能指针,创建生产的工厂unique_ptr< AbstractFactory> fac1(new XiaoMiFactory);unique_ptr< AbstractFactory> fac2(new HuaWeiFactory);//通过工厂来生产手机的unique_ptr< AbstractPhone > phone1(fac1->createPhone());unique_ptr< AbstractPhone > phone2(fac2->createPhone());phone1->show();phone2->show();//生产手环unique_ptr< AbstractCircle > cir1(fac1->createCircle());unique_ptr< AbstractCircle > cir2(fac2->createCircle());cir1->show();cir2->show();return 0;
}