【C++设计模式】工厂模式及实现

一、简单工厂模式

1.概念：简单工厂模式是属于创建型模式，又叫做静态工厂方法(static Factory Method)模式，简单工厂模式是由一个工厂对象决定创建出来哪一种产品类的实例。实质是由一个工厂类根据传入的参数，动态决定应该创建哪一类产品类(这些产品类继承自一个父类或接口)的实例。
2.使用场景：
(1)在程序中，需要创建的对象很多，导致对象的new操作多且杂时，需要使用简单工厂模式；
(2)由于对象的创建过程是我们不需要去关心的，而我们注重的是对象的实际操作，
所以，我们需要分离对象的创建和操作两部分，如此，方便后期的程序扩展和维护。
3.实现：

#include <iostream>
using namespace std;
typedef enum ProductTypeTag
{
    TypeA, TypeB, TypeC

}ProductType;


class Product
{
public:
    virtual void Show() = 0;
};

class ProductA : public Product
{
public:
    void Show()
    {
        cout << "I'm ProductA" << endl;
    }
};

class ProductB : public Product
{
public:
    void Show()
    {
        cout << "I'm ProductB" << endl;
    }
};

class ProductC : public Product
{
public:
    void Show()
    {
        cout << "I'm ProductC" << endl;
    }
};


class Factory
{
public:
    Product* CreateProduct(ProductType type)
    {
        switch (type)
        {
        case TypeA:
            return new ProductA();

        case TypeB:
            return new ProductB();

        case TypeC:
            return new ProductC();

        default:
            return NULL;
        }
    }
};

int main()
{
    Factory* ProductFactory = new Factory();
    Product* productObjA = ProductFactory->CreateProduct(TypeA);
    if (productObjA != NULL)
        productObjA->Show();

    Product* productObjB = ProductFactory->CreateProduct(TypeB);
    if (productObjB != NULL)
        productObjB->Show();

    Product* productObjC = ProductFactory->CreateProduct(TypeC);
    if (productObjC != NULL)
        productObjC->Show();

    delete ProductFactory;
    ProductFactory = NULL;

    delete productObjA;
    productObjA = NULL;

    delete productObjB;
    productObjB = NULL;

    delete productObjC;
    productObjC = NULL;

    return 0;
}

4.缺点：上面的简单工厂模式的缺点是当新增产品的时候就要去修改工厂的类，这就违反了开放封闭原则。

二、工厂方法模式

1.概念：一个用于创建对象的接口，让子类决定实例化哪一个类。
2.使用场景：
（1）在设计的初期，就考虑到产品在后期会进行扩展的情况下，可以使用工厂方法模式。
（2）产品结构较复杂的情况下，可以使用工厂方法模式。
3.实现：

#include<iostream>
using namespace std;
class Product
{
public:
	virtual void show() = 0;
};

class ProductA :public Product
{
public:
	void show()
	{
		cout << "I'm ProductA" << endl;
	}
};

class ProductB :public Product
{
public:
	void show()
	{
		cout << "I'm ProductB" << endl;
	}
};

class ProductC :public Product
{
public:
	void show()
	{
		cout << "I'm ProductC" << endl;
	}
};

class Factory
{
public:
	virtual Product* CreateProduct() = 0;
};

class FactoryA :public Factory
{
public:
	Product* CreateProduct()
	{
		return new ProductA();
	}
};

class FactoryB :public Factory
{
public:
	Product* CreateProduct()
	{
		return new ProductB();
	}
};

class FactoryC :public Factory
{
public:
	Product* CreateProduct()
	{
		return new ProductC();
	}
};

int main()
{
	Factory* factoryA = new FactoryA();
	Product* productObjA = factoryA->CreateProduct();
	productObjA->show();

	Factory* factoryB = new FactoryB();
	Product* productObjB = factoryB->CreateProduct();
	productObjB->show();

	Factory* factoryC = new FactoryC();
	Product* productObjC = factoryC->CreateProduct();
	productObjC->show();

	if (factoryA != NULL)
	{
		delete factoryA;
		factoryA = NULL;
	}

	if (factoryB != NULL)
	{
		delete factoryB;
		factoryB = NULL;
	}

	if (productObjA != NULL)
	{
		delete productObjA;
	}

	if (productObjB != NULL)
	{
		delete productObjB;
	}

	if (productObjC != NULL)
	{
		delete productObjC;
	}
	return 0;
}

4.缺点：假如我们A产品中有A1和A2两种型号的产品，B产品中有B1和B2两种型号的产品，那怎么办，上面两种工厂模式就不能解决了。

三、抽象工厂模式

1.概念：提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。
2.使用场景：
（1）主要用于创建一组（有多个种类）相关的产品，
（2）为它们提供创建的接口；就是当具有多个抽象角色时，抽象工厂便可以派上用场。
3.实现：

#include<iostream>
using namespace std;
class ProductA
{
public:
	virtual void show() = 0;
};

class ProductA1 :public ProductA
{
public:
	void show()
	{
		cout << "I'm ProductA1" << endl;
	}
};

class ProductA2 :public ProductA
{
public:
	void show()
	{
		cout << "I'm ProductA2" << endl;
	}
};

class ProductB
{
public:
	virtual void show() = 0;
};

class ProductB1 :public ProductB
{
public:
	void show()
	{
		cout << "I'm ProductB1" << endl;
	}
};

class ProductB2 :public ProductB
{
public:
	void show()
	{
		cout << "I'm ProductB2" << endl;
	}
};

class Factory
{
public:
	virtual ProductA* CreateProductA() = 0;
	virtual ProductB* CreateProductB() = 0;
};


class Factory1 : public Factory
{
public:
	ProductA* CreateProductA()
	{
		return new ProductA1();
	}

	ProductB* CreateProductB()
	{
		return new ProductB1();
	}
};

class Factory2 : public Factory
{
	ProductA* CreateProductA()
	{
		return new ProductA2();
	}

	ProductB* CreateProductB()
	{
		return new ProductB2();
	}
};

int main()
{
	Factory* factoryObj1 = new Factory1();
	ProductA* productObjA1 = factoryObj1->CreateProductA();
	ProductB* productObjB1 = factoryObj1->CreateProductB();

	productObjA1->show();
	productObjB1->show();

	Factory* factoryObj2 = new Factory2();
	ProductA* productObjA2 = factoryObj2->CreateProductA();
	ProductB* productObjB2 = factoryObj2->CreateProductB();

	productObjA2->show();
	productObjB2->show();

	if (factoryObj1 != NULL)
	{
		delete factoryObj1;
		factoryObj1 = NULL;
	}

	if (factoryObj2 != NULL)
	{
		delete factoryObj2;
		factoryObj2 = NULL;
	}

	if (productObjA1 != NULL)
	{
		delete productObjA1;
		productObjA1 = NULL;
	}

	if (productObjA2 != NULL)
	{
		delete productObjA2;
		productObjA2 = NULL;
	}

	if (productObjB1 != NULL)
	{
		delete productObjB1;
		productObjB1 = NULL;
	}

	if (productObjB2 != NULL)
	{
		delete productObjB2;
		productObjB2 = NULL;
	}
	return 0;
}