工厂模式（创建型）

工厂模式有：

• 简单工厂模式
• 工厂方法模式
• 抽象工厂模式

简单工厂模式：

简单工厂模式的方法为：通过一个工厂，工厂里面有一个创建的函数，通过输入type，通过switch的匹配，匹配成功的话，创建相应的产品，没有的话，返回nullptr。

具体的结构如下：

 代码的实现：

#include <iostream>
using namespace std;
class people//抽象主类
{
public:
    virtual void show() = 0;
};

class person : public people//preson类
{
public:
    virtual void show()
    {
        std::cout << "person构建成功" << std::endl;
    }
};

class son : public people//son类
{
public:
    virtual void show()
    {
        std::cout << "son构建成功" << std::endl;
    }
};

class man : public people//man类
{
public:
    virtual void show()
    {
        std::cout << "man构建成功" << std::endl;
    }
};


typedef enum product{persons,sons,mans}Product;//创建枚举类型

class SimpleFactory//简单工厂
{
public:
    people* create(Product type)
    {
        switch (type)
        {
        case persons:
            return new person;
        case sons:
            return new son;
        case mans:
            return new man;
        default:
            return nullptr;
        }
    }
};

int main()
{
    //创建一个简单工场
    SimpleFactory* factory = new SimpleFactory;
    //创建一个person类
    people* p = factory->create(persons);
    p->show();
    delete p;
    delete factory;
    return 0;
}

这种方法的缺点：当有新产品时，需要修改enum和工厂里面的switch（），这样的话比较繁琐，需要修改原有代码，背离了开-闭原则（对扩展开放，对修改关闭）

工厂方法模式：

 工厂方法模式：针对每一个产品都添加一个对应的一个工厂，这样的话添加产品的话只需要添加，产品和相应的工厂，而不需要修改原有的代码。

代码如下：

#include <iostream>
using namespace std;
class people//抽象主类
{
public:
    virtual void show() = 0;
};

class person : public people//preson类
{
public:
    virtual void show()
    {
        std::cout << "person构建成功" << std::endl;
    }
};
class son : public people//son类
{
public:
    virtual void show()
    {
        std::cout << "son构建成功" << std::endl;
    }
};
class man : public people//man类
{
public:
    virtual void show()
    {
        std::cout << "man构建成功" << std::endl;
    }
};

class Factory//工厂
{
public:
    virtual people* create() = 0;
};

class product_person:public Factory //person的工厂
{
    virtual people* create()
    {
        return new person;
    }
};
class product_son :public Factory //son的工厂
{
    virtual people* create()
    {
        return new son;
    }
};
class product_man :public Factory //man的工厂
{
    virtual people* create()
    {
        return new man;
    }
};

int main()
{
    //首先创建person工厂
    Factory* factory = new product_person;
    //创建产品
    people* p = factory->create();
    p->show();
    delete p;
    delete factory;
    return 0;

}

这种方法的缺点：在现实生活中，一个产品可能有多个部件，使用工厂模式的话，每个部件需要添加新的工厂，这样就比较复杂。

抽象工厂模式：

提供一个接口，让该接口负责一系列“相关或相关依赖的对象”，无需指定他们具体的类

缺点：增加一个新的产品，不仅要实现具体的 产品类，而且还要创建相关的工厂接口

//抽象类
class Age	//年龄
{
public:
	virtual void show() = 0;
};
class Height	//身高
{
public:
	virtual void show1() = 0;
};
class Weight	//体重
{
public:
	virtual void show2() = 0;
};
 
 
//man的Age
class man_age:public Age
{
public:
	virtual void show() { cout << "Age<<endl"; }
};
//man的Height
class man_height:public Height
{
public:
	virtual void show1() { cout << "Hge<<endl"; }
};
//man的Weight
class man_weight:public Weight
{
public:
	virtual void show2() { cout << "Weight<<endl"; }
};
 
 
//抽象工厂类
class Product
{
public:
	virtual Age* create_Age() = 0;
	virtual Height* create_Height() = 0;
	virtual Weight* create_Weight() = 0;
	virtual ~Product(){}
};
 
//man的工厂
class product_man :public Product
{
	virtual Age* create_Age()
	{
		return new man_age;
	}
	virtual Height* create_Height()
	{
		return new man_height;
	}
	virtual Weight* create_Weight()
	{
		return new man_weight;
	}
};