디자인 모드 - 창설 형 모드 의 Abstract Factory (추상 공장)

의도: 일련의 의존 대상 을 만 드 는 인 터 페 이 스 를 제공 합 니 다. 구체 적 인 종 류 를 지정 하지 않 아 도 됩 니 다.
코드:

#include <iostream>
using namespace std;
class Product1
{
public:
	virtual int Behavior() = 0;
};

class Product1A:public Product1
{
public:
	int Behavior()
	{
		cout << "Product1A finished
";
		return 1;
	}
};

class Product1B:public Product1
{
public:
	int Behavior()
	{
		cout << "Product1B finished
";
		return 1;
	}
};

class Product2
{
public:
	virtual int Behavior() = 0;
};

class Product2A:public Product2
{
public:
	int Behavior()
	{
		cout << "Product2A finished
";
		return 1;
	}
};

class Product2B:public Product2
{
public:
	int Behavior()
	{
		cout << "Product2B finished
";
		return 1;
	}
};

class AbstractFactory   //   Factory Method    
{
public:
	virtual Product1* CreateProduct1() = 0;
	virtual Product2* CreateProduct2() = 0;
};

class FactoryA:public AbstractFactory   //         Singleton
{
private:
	Product2A * p2A;
	Product1A * p1A;
	static FactoryA* mInstance;
	FactoryA(): p2A(0), p1A(0) {}
public:
	Product2* CreateProduct2()
	{
		if(p2A == 0)
			p2A = new Product2A();
		return p2A;
	}
	
	Product1* CreateProduct1()
	{
		if(p1A == 0)
			p1A = new Product1A();
		return p1A;
	}
	
	static FactoryA* GetInstance()
	{
		if(NULL == mInstance)
			mInstance = new FactoryA();
		return mInstance;
	}
	
	static void FreeInstance()
	{
		delete mInstance;
	}
	
	~FactoryA()
	{
		delete p2A;
		delete p1A;
	}
};
FactoryA* FactoryA::mInstance = NULL;

class FactoryB:public AbstractFactory
{
private:
	Product2B * p2B;
	Product1B * p1B;
	static FactoryB* mInstance;
	FactoryB(): p2B(0), p1B(0) {}
public:
	
	Product2* CreateProduct2()
	{	
		if(p2B == 0)
			p2B = new Product2B();
		return p2B;
	}
	
	Product1* CreateProduct1()
	{
		if(p1B == 0)
			p1B = new Product1B();
		return p1B;
	}
	
	static FactoryB* GetInstance()
	{
		if(NULL == mInstance)
			mInstance = new FactoryB();
		return mInstance;
	}
	
	static void FreeInstance()
	{
		delete mInstance;
	}
	
	~FactoryB()
	{
		delete p2B;
		delete p1B;
	}
};
FactoryB* FactoryB::mInstance = NULL;

int main()
{
	AbstractFactory* factoryA = FactoryA::GetInstance();
	Product1 *product1 = factoryA->CreateProduct1();
	product1->Behavior();	
	FactoryA::FreeInstance();
	
	AbstractFactory* factoryB = FactoryB::GetInstance();
	Product2 *product2 = factoryB->CreateProduct2();
	product2->Behavior();
	FactoryB::FreeInstance();
	return 1;
}

효과: 1. 구체 적 인 유형 2 를 분리 하여 교환 하기 쉬 운 제품 시리즈 3. 제품 의 일치 성에 유리 함 4. 새로운 종류의 제품 관련 모델 을 지원 하기 어렵다. 1. AbstractFactory 류 는 보통 Factory Method 공장 방법 2 구체 적 인 공장 을 사용 하여 Singleton 단일 부품 으로 만 들 수 있다.