Abstract Factory 抽象工厂模式

根据UML图简单代码进行演示过程如下：

Product.h

 

#ifndef _PRODUCT_H_ 
#define _PRODUCT_H_ 

class AbstractProductA 
{ 
public: 
	virtual ~AbstractProductA(); 
protected: 
	AbstractProductA(); 
private: 
}; 
class AbstractProductB 
{ 
public: 
	virtual ~AbstractProductB(); 
protected: 
	AbstractProductB(); 
private: 
}; 
class ProductA1:public AbstractProductA 
{ 
public: 
	ProductA1(); 
	~ProductA1(); 
protected: 
private:
}; 
class ProductA2:public AbstractProductA 
{ 
public: 
	ProductA2(); 
	~ProductA2(); 
protected: 
private:
}; 

class ProductB1:public AbstractProductB 
{ 
public: 
	ProductB1(); 
	~ProductB1(); 
protected: 
private: 
}; 
class ProductB2:public AbstractProductB 
{ 
public: 
	ProductB2(); 
	~ProductB2(); 
protected: 
private:
}; 
#endif 

 

AbstractFactory.h

#ifndef _ABSTRACTFACTORY_H_ 
#define _ABSTRACTFACTORY_H_ 
class AbstractProductA; 
class AbstractProductB; 
class AbstractFactory 
{ 
public: 
	virtual ~AbstractFactory(); 
	virtual  AbstractProductA* 
		CreateProductA()= 0;
	virtual  AbstractProductB* 
		CreateProductB()= 0;
protected: 
	AbstractFactory(); 
private: 
}; 
class ConcreteFactory1:public AbstractFactory
{ 
public: 
	ConcreteFactory1(); 
	~ConcreteFactory1(); 
	AbstractProductA* CreateProductA(); 
	AbstractProductB* CreateProductB(); 
protected: 
private: 
}; 
class ConcreteFactory2:public AbstractFactory
{ 
public: 
	ConcreteFactory2(); 
	~ConcreteFactory2(); 
	AbstractProductA* CreateProductA(); 
	AbstractProductB* CreateProductB(); 
protected: 
private: 
}; 
#endif 

两个cpp实现文件

#include"AbstractFactory.h" 
#include"Product.h" 
#include<iostream> 
using namespace std; 
AbstractFactory::AbstractFactory() 
{ 
} 
AbstractFactory::~AbstractFactory() 
{ 
} 
ConcreteFactory1::ConcreteFactory1() 
{ 
} 
ConcreteFactory1::~ConcreteFactory1() 
{ 
} 
AbstractProductA* 
	ConcreteFactory1::CreateProductA() 
{ 
	return new ProductA1(); 
} 
AbstractProductB* 
	ConcreteFactory1::CreateProductB() 
{ 
	return new ProductB1(); 
} 
ConcreteFactory2::ConcreteFactory2() 
{ 
} 
ConcreteFactory2::~ConcreteFactory2() 
{ 
} 
AbstractProductA* 
	ConcreteFactory2::CreateProductA() 
{ 
	return new ProductA2(); 
} 
AbstractProductB* 
	ConcreteFactory2::CreateProductB() 
{ 
	return new ProductB2(); 
}

 

#include"Product.h" 
#include<iostream> 
using namespace std; 

AbstractProductA::AbstractProductA() 
{

} 
AbstractProductA::~AbstractProductA() 
{

} 
AbstractProductB::AbstractProductB() 
{ 

} 
AbstractProductB::~AbstractProductB() 
{ 

} 
ProductA1::ProductA1() 
{ 
	cout<<"ProductA1..."<<endl; 
} 
ProductA1::~ProductA1() 
{ 
} 
ProductA2::ProductA2() 
{ 
	cout<<"ProductA2..."<<endl; 
} 
ProductA2::~ProductA2() 
{ 
} 
ProductB1::ProductB1() 
{ 
	cout<<"ProductB1..."<<endl; 
} 
ProductB1::~ProductB1() 
{ 
} 
ProductB2::ProductB2() 
{ 
	cout<<"ProductB2..."<<endl; 
} 
ProductB2::~ProductB2() 
{ 

} 

主函数测试文件

 

#include"AbstractFactory.h" 
#include<iostream> 
using namespace std; 

int main(int argc,char*argv[])
{ 
	AbstractFactory* cf1  = new 
		ConcreteFactory1(); 
	cf1->CreateProductA(); 
	cf1->CreateProductB(); 
	AbstractFactory* cf2  = new 
		ConcreteFactory2(); 
	cf2->CreateProductA(); 
	cf2->CreateProductB(); 
	return 0;
}

AbstractFactory模式的实现代码很简单，在测试程序中可以看到，当我们要创建一组对
象（ProductA1，ProductA2）的时候我们只用维护一个创建对象（ConcreteFactory1），大大
简化了维护的成本和工作。

AbstractFactory模式和Factory模式的区别是初学（使用）设计模式时候的一个容易引
起困惑的地方。实际上，AbstractFactory模式是为创建一组（有多类）相关或依赖的对象提
供创建接口，而Factory模式是为一类对象提供创建接口或延迟对象的创建到子类中实现。并且可以看到，AbstractFactory模式通常都是使用Factory模式实现（ConcreteFactory1）。