标签：blog http io ar os 使用 sp strong on
转自http://www.cnblogs.com/jiese/p/3156753.html
AbstractFactory
要创建一组相关或者相互依赖的对象
作用：提供一个创建一系列相关或相互依赖对象的接口，而无需指定他们具体的类
说明：
AbstractFactory模式关键就是将这一组对象的创建封装到一个用于创建对象的类（ConcreteFactory）中
Abstract Factory模式和Factory最大的差别就是抽象工厂创建的是一系列相关的对象,其中创建的实现其实采用的就是Factory模式的方法,对于某个实现的有一个派生出来的抽象工厂,另一个实现有另一个派生出来的工厂
抽象工厂需要特别注意的地方就是区分不同类型的产品和这些产品的不同实现.显而易见的,如果有n种产品同时有m中不同的实现,那么根据乘法原理可知有n*m个Factory模式的使用
AbstractFactory模式是为创建一组（有多类）相关或依赖的对象提供创建接口，而Factory模式是为一类对象提供创建接口或延迟对象的创建到子类中实现。并且可以看到，AbstractFactory模式通常都是使用Factory模式实现（ConcreteFactory1）。
Product.h
#ifndef _PRODUCT_H
#define _PRODUCT_H
class AbstractProductA
{
public:
virtual ~AbstractProductA()=0;
virtual void operation()=0;
protected:
AbstractProductA(); //屏蔽构造函数
};
class ProductA1:public AbstractProductA
{
public:
ProductA1();
virtual void operation();
virtual ~ProductA1();
};
class ProductA2:public AbstractProductA
{
public:
ProductA2();
virtual void operation();
virtual ~ProductA2();
};
class AbstractProductB
{
public:
virtual ~AbstractProductB()=0;
virtual void operation()=0;
protected:
AbstractProductB();//屏蔽构造函数
};
//派生类ProductB1，继承自AbstractProductB，B类产品的一种实现
class ProductB1:public AbstractProductB
{
public:
ProductB1();
virtual void operation();
virtual ~ProductB1();
};
//派生类ProductB2，继承自AbstractProductB，B类产品的另一种实现
class ProductB2:public AbstractProductB
{
public:
ProductB2();
virtual void operation();
virtual ~ProductB2();
};
#endif
Factory.h
#ifndef _FACTORY_H
#define _FACTORY_H
class AbstractProductA;
class AbstractProductB;
class AbstractFactory
{
public:
virtual ~AbstractFactory()=0;
virtual AbstractProductA* CreateProductA()=0;
virtual AbstractProductB* CreateProductB()=0;
protected:
AbstractFactory();
};
//ConcreteFactory1，派生类，继承自AbstractFactory
//实现继承的接口，生产产品A和B的一种实现
class ConcreteFactory1:public AbstractFactory
{
public:
ConcreteFactory1();
~ConcreteFactory1();
virtual AbstractProductA* CreateProductA();
virtual AbstractProductB* CreateProductB();
};
class ConcreteFactory2:public AbstractFactory
{
public:
ConcreteFactory2();
~ConcreteFactory2();
virtual AbstractProductA* CreateProductA();
virtual AbstractProductB* CreateProductB();
};
#endif
Product.cpp
#include "Product.h"
#include <iostream>
using namespace std;
AbstractProductA::AbstractProductA()
{
cout<<"AbstractProductA..."<<endl;
}
AbstractProductA::~AbstractProductA()
{
cout<<"~AbstractProductA..."<<endl;
}
//ProductA1
ProductA1::ProductA1()
{
cout<<"ProductA1..."<<endl;
}
ProductA1::~ProductA1()
{
cout<<"ProductA1..."<<endl;
}
void ProductA1::operation()
{}
//ProductA2
ProductA2::ProductA2()
{
cout << "ProductA2..." << endl;
}
ProductA2::~ProductA2()
{
cout << "~ProductA2..." << endl;
}
void ProductA2::operation()
{}
//AbstractProductB
AbstractProductB::AbstractProductB()
{
cout << "AbstractProductB..." << endl;
}
AbstractProductB::~AbstractProductB()
{
cout << "~AbstractProductB..." << endl;
}
//ProductB1
ProductB1::ProductB1()
{
cout << "ProductB1..." << endl;
}
ProductB1::~ProductB1()
{
cout << "~ProductB1..." << endl;
}
void ProductB1::operation()
{}
//ProductB2
ProductB2::ProductB2()
{
cout << "ProductB2..." << endl;
}
ProductB2::~ProductB2()
{
cout << "~ProductB2..." << endl;
}
void ProductB2::operation()
{}
Factory.cpp
#include "Factory.h"
#include "Product.h"
#include <iostream>
using namespace std;
AbstractFactory::AbstractFactory()
{
cout << "AbstractFactory..." << endl;
}
AbstractFactory::~AbstractFactory()
{
cout << "~AbstractFactory..." << endl;
}
ConcreteFactory1::ConcreteFactory1()
{
cout << "ConcreteFactory1..." << endl;
}
ConcreteFactory1::~ConcreteFactory1()
{
cout << "~ConcreteFactory1..." << endl;
}
AbstractProductA* ConcreteFactory1::CreateProductA()
{
return new ProductA1();
}
AbstractProductB* ConcreteFactory1::CreateProductB()
{
return new ProductB1();
}
ConcreteFactory2::ConcreteFactory2()
{
cout << "ConcreteFactory2..." << endl;
}
ConcreteFactory2::~ConcreteFactory2()
{
cout << "~ConcreteFactory2..." << endl;
}
AbstractProductA* ConcreteFactory2::CreateProductA()
{
return new ProductA2();
}
AbstractProductB* ConcreteFactory2::CreateProductB()
{
return new ProductB2();
}
main.cpp
#include <iostream>
#include "Factory.h"
#include "Product.h"
using namespace std;
int main()
{
AbstractFactory* fa1 = new ConcreteFactory1();
AbstractProductA* a1 = fa1->CreateProductA();
AbstractProductB* b1 = fa1->CreateProductB();
cout << endl;
AbstractFactory* fa2 = new ConcreteFactory2();
AbstractProductA* a2 = fa2->CreateProductA();
AbstractProductB* b2 = fa2->CreateProductB();
cout << endl;
delete fa1;
delete a1;
delete b1;
cout << endl;
delete fa2;
delete a2;
delete b2;
return 0;
}
标签：blog http io ar os 使用 sp strong on
原文地址：http://www.cnblogs.com/chillblood/p/4113674.html
