【C++设计模式】抽象工厂模式

#ifndef __ABSTRACTFACTORY_H__
#define __ABSTRACTFACTORY_H__

#include <string>

//【说明】
// 当产品结构比较复杂的时候，工厂方法也无法满足产品的划分和构建。如A,B是一类产品，而中国制造的A,B和美国制造的A,B又要区分为不同的产品族。
// 抽象工厂将创建A,B对象的接口都放到一个基类中，子类在产品族的层面来扩展，通过不同的接口创建不同的对象。

//【定义】
// 抽象工厂模式 ：提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。

//【角色】
// 1) 抽象产品（Product）：描述具体产品的公共接口。
// 2) 具体产品（ConcreteProduct）：工厂类创建的目标类，描述生产的具体产品。
// 3) 抽象工厂（Creator）：声明一系列创建产品的工厂方法接口，返回抽象产品。
// 4) 真实工厂（ConcreteCreator）：实现抽象工厂的方法，返回某个产品的实例，由客户调用。

//【意义】
// 抽象工厂的工作是将"抽象零件"组装为"抽象产品"，我们并不关心零件的具体实现，而是只关心接口(API)，我们仅使用接口(API)将零件组装为产品。
// 当在两个维度上细化产品类型时，抽象工厂给出了如何创建对象的一种方案，但是随着产品类型的细化也带来了工厂类数量的剧增。

//【示例】

//产品A,B属于一类产品
class iProductA 
{
public:	
	iProductA(){ }

	virtual ~iProductA(){ }

public:	
	virtual void PrintProductA() = 0;
};

class iProductB
{
public:	
	iProductB(){ }

	virtual ~iProductB(){ }

public:	
	virtual void PrintProductB() = 0;
};

//中国制造和美国制造属于不同产品族
class ChinaProductA : public iProductA
{
public:
	virtual void PrintProductA();
};

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

class AmericaProductA : public iProductA
{
public:
	virtual void PrintProductA();
};

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

//抽象工厂，提供创建一类产品的接口
class iAbstractFactory
{
public:	
	iAbstractFactory(){ }

	virtual ~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"

void ChinaProductA::PrintProductA()
{
	printf("Print ChinaProductA. \n");
}

void ChinaProductB::PrintProductB()
{
	printf("Print ChinaProductB. \n");
}

void AmericaProductA::PrintProductA()
{
	printf("Print AmericaProductA. \n");
}

void AmericaProductB::PrintProductB()
{
	printf("Print AmericaProductB. \n");
}

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

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

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

iProductB* AmericaFactory::CreateProductB()
{
	return new 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;
}

【C++设计模式】抽象工厂模式

猜你喜欢