C++ 工厂模式（原理+代码）

工厂模式使用了多态模式的特性，将存在继承关系的类，通过一个工厂类创建对应的子类对象，在项目复杂的情况下，这样建工厂比较方便。
工厂模式分为简单工厂模式、工厂方法模式、抽象工厂模式

简单工厂模式的结构组成
1.抽象产品类：具体产品类继承的父类和实现的接口
2.具体产品类：工厂类所创建的对象
3.工厂类：工厂模式的核心类，用于创建具体产品类的实例对象

简单工厂模式的缺点：
扩展性有限，当需要增加新的产品类时，需要修改工厂类中的生成产品接口。

#include <iostream>
//抽象产品类
class Product
{
public:
	virtual ~Product(){};
	virtual void show()=0;
};
//具体产品类1
class Product_1 :public Product
{
public:
	void show()
	{
		std::cout << "这是产品1" << std::endl;
	};
};

//具体产品类2
class Product_2 :public Product
{
public:
	void show()
	{
		std::cout << "这是产品2" << std::endl;
	};
};
enum  ProductType
{
	first,
	scecond
};


//工厂类
class Factory
{

public:
	Product* CreateProduct(ProductType type)
	{
		switch (type)
		{
		case first:
			return new Product_1();
		case scecond:
			return new Product_2();
		default:
			return NULL;
		break;
		}
	};
};

int main()
{
	//构建工厂对象
	Factory factory;
	Product* productOne = factory.CreateProduct(first);
	if (productOne !=NULL)
	{
		productOne->show();
		delete productOne;
		productOne = NULL;
	}
	
	Product* productTwo = factory.CreateProduct(scecond);
	if (productTwo != NULL)
	{
		productTwo->show();
		delete productTwo;
		productTwo = NULL;
	}

}

 

工厂模式的组成：
1.抽象产品类：具体产品类的基类
2.具体产品类：具体工厂类产生的类
3.抽象工厂类：工厂模式的核心类，具体工厂模式的基类，提供创建具体产品的接口，有具体工厂类实现
4.具体工厂类：继承于抽象工厂类，用于创建具体产品对象

工厂方法模式的缺点：
1.一条生成线只能生产一种产品
2.每增加一种产品，就需要增加一种具体产品类和具体工厂类

/抽象产品类
#include<iostream>
using  namespace std;
class Product
{
public:
    virtual ~Product() {};
    virtual  void show() = 0;
};
//具体产品1
class Product_1:public Product
{
public:
    void show()
    {
        std::cout << "工厂模式，产品1" << std::endl;
    };

};

//具体产品2
class Product_2 :public Product
{
public:
    void show()
    {
        std::cout << "工厂模式，产品2" << std::endl;
    };

};

//抽象工厂类
class factory
{
public:
    virtual ~factory() {};
    virtual Product* createProduct()= 0;
};
//具体工厂类1
class factoryOne :public factory
{
public:
    Product* createProduct()
    {
        return new Product_1();
    };
};

//具体工厂类2
class factoryTwo :public factory
{
public:
    Product* createProduct()
    {
        return new Product_2();
    };
};

int main()
{
    //生产产品1的流程。。。。。。
    //产品1的生成工厂
    factoryOne* factory1 = new factoryOne();
    //工厂1生产产品1
    Product *product1  = factory1->createProduct();
    //产品1展示
    product1->show();

    //生产产品2的流程。。。。。。
    //产品2的生成工厂
    factoryTwo* factory2 = new factoryTwo();
    //工厂1生产产品1
    Product* product2 = factory2->createProduct();
    //产品1展示
    product2->show();

    //记得析构一下

}

抽象工厂模式

抽象产品类：具体产品类的基类
具体产品类：具体工厂所创建的对象
抽象工厂类：工厂方法模式的核心类，提供创建具体产品的接口，有具体工厂类实现
具体工厂类：继承于抽象工厂类，实现创建对应具体产品对象的方式

抽象工厂模式的特点：
提供一个接口，可以创建多个产品族中的产品对象

 

/抽象产品类
//抽象产品tea（茶）
#include <iostream>
class tea
{
public:

    virtual ~tea() {};
    virtual void show() = 0;
};
//具体产品 greenTea(绿茶)
class greenTea :public tea
{
public:
    void show()
    {
        std::cout << "这是工厂生产的绿茶"<<std::endl;
    }
};

//抽象产品类 coffee
class coffee
{
public:
    virtual ~coffee() {};
    virtual void show() = 0;
};

//具体产品类 whitecoffee （白咖啡）
class whitecoffee :public coffee
{
public:
    void show()
    {
        std::cout << "这是工厂生产的白咖啡" << std::endl;
    }
};

//抽象工厂
class factory
{
public:
    virtual~factory() {};
    virtual tea* createtea()=0;
    virtual coffee* createCoffee() = 0;
};
//具体工厂类 （生产绿茶和白咖啡）
class myfactory :public factory
{
public:
    tea* createtea()
    {
        return new greenTea();
    };

    coffee* createCoffee()
    {
        return new whitecoffee();
    }
};


int main()
{
    myfactory fac;
    tea* myTea = fac.createtea();
    coffee* mycoffee  =fac.createCoffee();
    myTea->show();
    mycoffee->show();
    delete myTea;
    delete mycoffee;
    myTea = NULL;
    mycoffee = NULL;
}