#ifndef __ABSTRACTFACTORY_H__
#define __ABSTRACTFACTORY_H__

#include <string>
#include <iostream>

//抽象工廠模式

//定義：抽象工廠提供一個建立一系列相關或相互依賴物件的介面，而無需指定它們具體的類。

//當產品結構比較複雜的時候，工廠方法也無法滿足產品的劃分和構建。

//如A,B是一類產品，而中國製造的A,B和美國製造的A,B又要區分為不同的產品族。

//抽象工廠將建立A,B物件的介面都放到一個基類中，子類在產品族的層面來擴充套件，通過不同的介面建立不同的物件。

//抽象工廠的工作是將"抽象零件"組裝為"抽象產品"，我們並不關心零件的具體實現，而是隻關心介面(API)，我們僅使用介面(API)將零件組裝為產品。


//產品A,B屬於一類產品
class iProductA 
{
public:	
	virtual void PrintProductA() = 0;
};

class iProductB
{
public:	
	virtual void PrintProductB() = 0;
};

//中國製造和美國製造屬於不同產品族
class ChinaProductA : public iProductA
{
public:
	ChinaProductA(const std::string &name);

	virtual void PrintProductA();

private:
	std::string m_name;
};

class ChinaProductB : public iProductB
{
public:
	ChinaProductB(const std::string &name);

	virtual void PrintProductB();

private:
	std::string m_name;
};

class AmericaProductA : public iProductA
{
public:
	AmericaProductA(const std::string &name);

	virtual void PrintProductA();

private:
	std::string m_name;
};

class AmericaProductB : public iProductB
{
public:
	AmericaProductB(const std::string &name);

	virtual void PrintProductB();

private:
	std::string m_name;
};

//當在兩個維度上細化產品型別時，抽象工廠給出瞭如何建立物件的一種方案，但是隨著產品型別的細化也帶來了工廠類數量的劇增。

//抽象工廠，提供建立一類產品的介面
class iAbstractFactory
{
public:		

	virtual iProductA* CreateProductA() = 0 ;

	virtual iProductB* CreateProductB() = 0 ;
		
};

//子類繼承抽象工廠對產品族進行分類
class ChinaFactory: public iAbstractFactory
{
public:

	virtual iProductA* CreateProductA();

	virtual iProductB* CreateProductB();

};

class AmericaFactory: public iAbstractFactory
{
public:

	virtual iProductA* CreateProductA();

	virtual iProductB* CreateProductB();

};

void TestAbstractFactory();

#endif


 

#include "AbstractFactory.h"

ChinaProductA::ChinaProductA(const std::string &name)
{
	m_name = name;
}

void ChinaProductA::PrintProductA()
{
	printf("PrintProductA %s\n", m_name.c_str());
}

ChinaProductB::ChinaProductB(const std::string &name)
{
	m_name = name;
}

void ChinaProductB::PrintProductB()
{
	printf("PrintProductB %s\n", m_name.c_str());
}

AmericaProductA::AmericaProductA(const std::string &name)
{
	m_name = name;
}

void AmericaProductA::PrintProductA()
{
	printf("PrintProductA %s\n", m_name.c_str());
}

AmericaProductB::AmericaProductB(const std::string &name)
{
	m_name = name;
}

void AmericaProductB::PrintProductB()
{
	printf("PrintProductB %s\n", m_name.c_str());
}

iProductA* ChinaFactory::CreateProductA()
{
	return new ChinaProductA("ChinaProductA");
}

iProductB* ChinaFactory::CreateProductB()
{
	return new ChinaProductB("ChinaProductB");
}

iProductA* AmericaFactory::CreateProductA()
{
	return new AmericaProductA("AmericaProductA");
}

iProductB* AmericaFactory::CreateProductB()
{
	return new AmericaProductB("AmericaProductB");
}

void TestAbstractFactory()
{
	iAbstractFactory *cf = new ChinaFactory();

	iProductA *ca = cf->CreateProductA();

	iProductB *cb = cf->CreateProductB();

	ca->PrintProductA();

	cb->PrintProductB();

	delete cf; 
	delete ca;
	delete cb;

	iAbstractFactory * af = new AmericaFactory();

	iProductA *aa = af->CreateProductA();

	iProductB *ab = af->CreateProductB();

	aa->PrintProductA();

	ab->PrintProductB();

	delete af; 
	delete aa;
	delete ab;
}