C++ 工厂模式（Factory Pattern）

//FactoryPattern.h

#pragma once
#include <iostream>

//base one factory pattern.
enum PRODUCT { ONE, TWO, THREE, FOUR };
class SimpleAbstractProduct
{
public:
	virtual void Print() = 0;
};
class SimpleOneAbstractProduct :public SimpleAbstractProduct
{
public:
	~SimpleOneAbstractProduct() {}
	void Print() { std::cout << "This is SimpleOneAbstractProduct class." << std::endl; }
};
class SimpleTwoAbstractProduct :public SimpleAbstractProduct
{
public:
	~SimpleTwoAbstractProduct() {}
	void Print() { std::cout << "This is SimpleTwoAbstractProduct class." << std::endl; }
};
class SimpleThreeAbstractProduct :public SimpleAbstractProduct
{
public:
	~SimpleThreeAbstractProduct() {}
	void Print() { std::cout << "This is SimpleThreeAbstractProduct class." << std::endl; }
};
class SimpleFourAbstractProduct :public SimpleAbstractProduct
{
public:
	~SimpleFourAbstractProduct() {}
	void Print() { std::cout << "This is SimpleFourAbstractProduct class." << std::endl; }
};
class SimpleFactory
{
public:
	static SimpleAbstractProduct* CreateSimpleAbstractProduct(PRODUCT product)
	{
		switch (product)
		{
		case ONE:
			return new SimpleOneAbstractProduct();
			break;
		case TWO:
			return new SimpleTwoAbstractProduct();
			break;
		case THREE:
			return new SimpleThreeAbstractProduct();
			break;
		case FOUR:
			return new SimpleFourAbstractProduct();
			break;
		default:
			return nullptr;
			break;
		}
	}
};
//Factory Method Pattern.
class MethodFactory
{
public:
	virtual SimpleAbstractProduct* CreateSimpleAbstractProduct() = 0;
};
class OneImplementMethodFactory:public MethodFactory
{
public:
	SimpleAbstractProduct* CreateSimpleAbstractProduct()
	{
		return new SimpleOneAbstractProduct();
	}
};
class TwoImplementMethodFactory:public MethodFactory
{
public:
	SimpleAbstractProduct* CreateSimpleAbstractProduct()
	{
		return new SimpleTwoAbstractProduct();
	}
};
class ThreeImplementMethodFactory:public MethodFactory
{
public:
	SimpleAbstractProduct* CreateSimpleAbstractProduct()
	{
		return new SimpleThreeAbstractProduct();
	}
};
class FourImplementMethodFactory:public MethodFactory
{
public:
	 SimpleAbstractProduct* CreateSimpleAbstractProduct()
	{
		return new SimpleFourAbstractProduct();
	}
};
//Abstract Factory Pattern
class AbstractProduct
{
public:
	virtual void Print() = 0;
};
class OneAbstractProduct :public AbstractProduct
{
public:
	~OneAbstractProduct() {};
	void Print()
	{
		std::cout << "This is OneAbstractProduct." << std::endl;
	}
};
class TwoAbstractProduct :public AbstractProduct
{
public:
	~TwoAbstractProduct() {};
	void Print()
	{
		std::cout << "This is TwoAbstractProduct." << std::endl;
	}
};
class ThreeAbstractProduct :public AbstractProduct
{
public:
	~ThreeAbstractProduct() {};
	void Print()
	{
		std::cout << "This is ThreeAbstractProduct." << std::endl;
	}
};
class FourAbstractProduct :public AbstractProduct
{
public:
	~FourAbstractProduct() {};
	void Print()
	{
		std::cout << "This is FourAbstractProduct." << std::endl;
	}
};
class AbstractProductFactory
{
public:
	virtual AbstractProduct* CreateAbstractProduct() = 0;
};
class OneAbstractProductFactory :public AbstractProductFactory
{
public:
	AbstractProduct * CreateAbstractProduct()
	{
		return new OneAbstractProduct();
	}
};
class TwoAbstractProductFactory :public AbstractProductFactory
{
public:
	AbstractProduct * CreateAbstractProduct()
	{
		return new TwoAbstractProduct();
	}
};
class ThreeAbstractProductFactory :public AbstractProductFactory
{
public:
	AbstractProduct * CreateAbstractProduct()
	{
		return new ThreeAbstractProduct();
	}
};
class FourAbstractProductFactory :public AbstractProductFactory
{
public:
	AbstractProduct * CreateAbstractProduct()
	{
		return new FourAbstractProduct();
	}
};
class  AbstractFactory
{
public:
	virtual SimpleAbstractProduct* CreateSimpleAbstractProduct()=0;
	virtual AbstractProduct* CreateAbstractProduct()=0;
};
class OneAbstractFactory:public AbstractFactory
{
private:
	OneImplementMethodFactory* Oimf;
	OneAbstractProductFactory* Oapf;
public:
	OneAbstractFactory() { Oimf = new OneImplementMethodFactory(); Oapf = new OneAbstractProductFactory(); }
	~OneAbstractFactory() { delete Oimf; delete Oapf; }
	SimpleAbstractProduct* CreateSimpleAbstractProduct()
	{
		return Oimf->CreateSimpleAbstractProduct();
	}
	AbstractProduct* CreateAbstractProduct()
	{
		return Oapf->CreateAbstractProduct();
	}
}; 
class TwoAbstractFactory:public AbstractFactory
{
private:
	TwoImplementMethodFactory* Tapf;
	TwoAbstractProductFactory* Stap;
public:
	TwoAbstractFactory() {Tapf = new TwoImplementMethodFactory(); Stap = new TwoAbstractProductFactory();}
	~TwoAbstractFactory() { delete Tapf; delete Stap; }
	SimpleAbstractProduct* CreateSimpleAbstractProduct()
	{
		return Tapf->CreateSimpleAbstractProduct();
	}; 
	AbstractProduct* CreateAbstractProduct() 
	{
		return Stap->CreateAbstractProduct();
	}
};
class ThreeAbstractFactory:public AbstractFactory
{
private:
	ThreeImplementMethodFactory * Timf;
	ThreeAbstractProductFactory* Tapf;
public:
	ThreeAbstractFactory() { Timf = new ThreeImplementMethodFactory(); Tapf = new ThreeAbstractProductFactory(); }
	~ThreeAbstractFactory() { delete Timf; delete Tapf;}
	SimpleAbstractProduct* CreateSimpleAbstractProduct()
	{
	    return Timf->CreateSimpleAbstractProduct();
	}
	AbstractProduct* CreateAbstractProduct()
	{
		return Tapf->CreateAbstractProduct();
	}
};
class FourAbstractFactory:public AbstractFactory
{
private:
	FourImplementMethodFactory * Fimf;
	FourAbstractProductFactory* Fapf;
public:
	FourAbstractFactory() { Fimf = new FourImplementMethodFactory(); Fapf = new FourAbstractProductFactory(); }
	~FourAbstractFactory() { delete Fimf; delete Fapf; }
	SimpleAbstractProduct* CreateSimpleAbstractProduct()
	{
		return Fimf->CreateSimpleAbstractProduct();
	};
	AbstractProduct* CreateAbstractProduct()
	{
		return Fapf->CreateAbstractProduct();
	}
};

//FactoryPattern.cpp

#include "FactoryPattern.h"

int main()
{
	//base one Pattern
	SimpleAbstractProduct* OneProduct = SimpleFactory::CreateSimpleAbstractProduct(PRODUCT::ONE);
	SimpleAbstractProduct* TwoProduct = SimpleFactory::CreateSimpleAbstractProduct(PRODUCT::TWO);
	SimpleAbstractProduct* ThreeProduct = SimpleFactory::CreateSimpleAbstractProduct(PRODUCT::THREE);
	SimpleAbstractProduct* FourProduct = SimpleFactory::CreateSimpleAbstractProduct(PRODUCT::FOUR);

	OneProduct->Print();
	TwoProduct->Print();
	ThreeProduct->Print();
	FourProduct->Print();

	delete OneProduct;
	delete TwoProduct;
	delete ThreeProduct;
	delete FourProduct;

	//Factory Method Pattern
	MethodFactory* OneMf = new OneImplementMethodFactory();
	SimpleAbstractProduct* OneSap=OneMf->CreateSimpleAbstractProduct();
	OneSap->Print();
	MethodFactory* TwoMf = new TwoImplementMethodFactory();
	SimpleAbstractProduct* TwoSap=TwoMf->CreateSimpleAbstractProduct();
	TwoSap->Print();
	MethodFactory* ThreeMf = new ThreeImplementMethodFactory();
	SimpleAbstractProduct* ThreeSap=ThreeMf->CreateSimpleAbstractProduct();
	ThreeSap->Print();

	MethodFactory* FourMf = new FourImplementMethodFactory();
	SimpleAbstractProduct* FourSap=FourMf->CreateSimpleAbstractProduct();
	FourSap->Print();

	delete OneSap;
	delete TwoSap;
	delete ThreeSap;
	delete FourSap;
	delete OneMf;
	delete TwoMf;
	delete ThreeMf;
	delete FourMf;

//	//Abstract Factory Pattern
	AbstractFactory* OneAf = new OneAbstractFactory();
	AbstractProduct* OneAp = OneAf->CreateAbstractProduct();
	SimpleAbstractProduct* OneSapt = OneAf->CreateSimpleAbstractProduct();
	OneAp->Print();
	OneSapt->Print();

	AbstractFactory* TwoAf = new TwoAbstractFactory();
	AbstractProduct* TwoAp=TwoAf->CreateAbstractProduct();
	SimpleAbstractProduct* TwoSapt=TwoAf->CreateSimpleAbstractProduct();
	TwoAp->Print();
	TwoSapt->Print();

	AbstractFactory* ThreeAf = new ThreeAbstractFactory();
	AbstractProduct* ThreeAp=ThreeAf->CreateAbstractProduct();
	SimpleAbstractProduct* ThreeSapt=ThreeAf->CreateSimpleAbstractProduct();
	ThreeAp->Print();
	ThreeSapt->Print();

	AbstractFactory* FourAf = new FourAbstractFactory();
	AbstractProduct* FourAp=FourAf->CreateAbstractProduct();
	SimpleAbstractProduct* FourSapt=FourAf->CreateSimpleAbstractProduct();
	FourAp->Print();
	FourSapt->Print();

	delete OneAp;
	delete TwoAp;
	delete ThreeAp;
	delete FourAp;
	delete OneSapt;
	delete TwoSapt;
	delete ThreeSapt;
	delete FourSapt;
	delete OneAf;
	delete TwoAf;
	delete ThreeAf;
	delete FourAf;
	system("pause");
	return 0;
}