设计模式之抽象工厂模式

 

 

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

优点：

1. 在一个应用中只需要在初始化的时候出现一次，这就使得改变一个应用的具体工厂变得非常容易，只需改变具体工厂即可使用不同的产品配置。
2. 它让具体的创建实例过程与客户端分离，客户端是通过他们的抽象接口操作实例，产品的具体类名也被具体工厂的实现分离，不会出现在代码中。

缺点：

增加新的功能时，需要添加相应的类。

代码实现：

abstract.h

#ifndef _ABSTRACTPRODUCTA_H_
#define _ABSTRACTPRODUCTA_H_

#include <iostream>

class AbstractProductA
{
	public:
		AbstractProductA();
		virtual ~AbstractProductA();
		virtual void operationA() = 0;
};


class ProductA_1 : public AbstractProductA
{
	public:
		ProductA_1();
		virtual ~ProductA_1();
		void operationA();
};

class ProductA_2 : public AbstractProductA
{
	public:
		ProductA_2();
		virtual ~ProductA_2();
		void operationA();
};

#endif

abstract.cpp

#include "abstract.h"

AbstractProductA::AbstractProductA(){}
AbstractProductA::~AbstractProductA(){}





ProductA_1::ProductA_1(){}
ProductA_1::~ProductA_1(){}
void ProductA_1::operationA()
{
	fprintf(stderr,"productA_1 operation!\n");
}



ProductA_2::ProductA_2(){}
ProductA_2::~ProductA_2(){}
void ProductA_2::operationA()
{
	fprintf(stderr,"productA_2 operation!\n");
}

abstractB.h

#ifndef _ABSTRACTPRODUCTB_H_
#define _ABSTRACTPRODUCTB_H_

#include <iostream>

class AbstractProductB
{
	public:
		AbstractProductB();
		virtual ~AbstractProductB();
		virtual void operationB() = 0;
};


class ProductB_1 : public AbstractProductB
{
	public:
		ProductB_1();
		virtual ~ProductB_1();
		void operationB();
};

class ProductB_2 : public AbstractProductB
{
	public:
		ProductB_2();
		virtual ~ProductB_2();
		void operationB();
};

#endif

abstractB.cpp

#include "abstractB.h"

AbstractProductB::AbstractProductB(){}
AbstractProductB::~AbstractProductB(){}





ProductB_1::ProductB_1(){}
ProductB_1::~ProductB_1(){}
void ProductB_1::operationB()
{
	fprintf(stderr,"productB_1 operation!\n");
}



ProductB_2::ProductB_2(){}
ProductB_2::~ProductB_2(){}
void ProductB_2::operationB()
{
	fprintf(stderr,"productB_2 operation!\n");
}

abstractfactory.h

#ifndef _ABSTRACTFACTORY_H_
#define _ABSTRACTFACTORY_H_

#include <iostream>
#include "abstract.h"
#include "abstractB.h"

class AbstractFactory
{
	public:
		AbstractFactory();
		virtual ~AbstractFactory();
		virtual AbstractProductA* createProductA() = 0;
		virtual AbstractProductB* createProductB() = 0;
};


class Factory1 : public AbstractFactory
{
	public:
		Factory1();
		~Factory1();
		AbstractProductA* createProductA();
		AbstractProductB* createProductB();
};

class Factory2 : public AbstractFactory
{
	public:
		Factory2();
		~Factory2();
		AbstractProductA* createProductA();
		AbstractProductB* createProductB();
};

#endif

abstractfactory.cpp

#include "abstractfactory.h"


AbstractFactory::AbstractFactory(){}
AbstractFactory::~AbstractFactory(){}


Factory1::Factory1(){}
Factory1::~Factory1(){}
AbstractProductA* Factory1::createProductA()
{
	AbstractProductA* temp = NULL;
	temp = new ProductA_1();
	return temp;
}
AbstractProductB* Factory1::createProductB()
{
	AbstractProductB* temp = NULL;
	temp = new ProductB_1();
	return temp;
}



Factory2::Factory2(){}
Factory2::~Factory2(){}
AbstractProductA* Factory2::createProductA()
{
	AbstractProductA* temp = NULL;
	temp = new ProductA_2();
	return temp;
}
AbstractProductB* Factory2::createProductB()
{
	AbstractProductB* temp = NULL;
	temp = new ProductB_2();
	return temp;
}

#include "abstractfactory.h"

int main()
{
	AbstractFactory* factory = new Factory1();
	AbstractProductA* productA = factory->createProductA();
	AbstractProductB* productB = factory->createProductB();
	productA->operationA();
	productB->operationB();
	
	
	delete factory;
	factory = NULL;
	delete productA;
	productA = NULL;
	delete productB;
	productB = NULL;
	
	
	factory = new Factory2();
	productA = factory->createProductA();
	productB = factory->createProductB();
	productA->operationA();
	productB->operationB();
	
	
	delete factory;
	factory = NULL;
	delete productA;
	productA = NULL;
	delete productB;
	productB = NULL;
	
	return 0;
}