23种设计模式学习—AbstractFactory模式

一下是《设计模式精解-GoF 23 种设计模式解析附 C 实现源码》中对AbstractFacotry的摘要：

AbstractFactory适用性:
1) 一个系统要独立于它的产品的创建、组合和表示时。
2)一个系统要由多个产品系列中的一个来配置时。
3) 当你要强调一系列相关的产品对象的设计以便进行联合使用时。
4) 当你提供一个产品类库,而只想显示它们的接口而不是实现时。

AbstractFactory一些优点和缺点：
1）它分离具体的类
2) 它使得易于交换产品系列
3) 它有利于产品的一致性
4) 难 以 支 持 新 种 类 的 产 品

AbstractFactory的结构如下如所示：

AbstractFactory 模式就是用来解决这类问题的:要创建一组相关或者相互依赖的对象

AbstractFactory 模式关键就是将这一组对象的创建封装到一个用于创建对象的类

AbstractFactory 模式是为创建一组(有多类)相关或依赖的对象提供创建接口,而 Factory 模式正如我在相应的文档中分析的是为一类对象提供创建接口或延迟对象的创建到子类中实现。并且可以看到,AbstractFactory 模式通常都是使用 Factory 模式实现

简单的实现代码如下：

 /* FileName : Product.h */

#ifndef _PRODUCT_H_
#define _PRODUCT_H_

class AbstractProductA
{
public:
     virtual ~AbstractProductA() ;
protected:
     AbstractProductA() ;
} ;

class AbstractProductB
{
public:
     virtual ~AbstractProductB() ;
protected:
     AbstractProductB() ;
} ;

class ProductA1 : public AbstractProductA
{
public :
     ProductA1() ;
     ~ProductA1() ;
};

class ProductA2 : public AbstractProductA
{
public :
     ProductA2() ;
     ~ProductA2() ;
};

class ProductB1 : public AbstractProductB
{
public :
     ProductB1() ;
     ~ProductB1() ;
};

class ProductB2 : public AbstractProductB
{
public :
     ProductB2() ;
     ~ProductB2() ;
};

#endif


/* FileName : Product.cpp */

#ifndef _PRODUCT_CPP_
#define _PRODUCT_CPP_

#include "Product.h"
#include <cstdio>

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

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

ProductA1::ProductA1() {
    puts( "ProductA1.." ) ;
}
ProductA1::~ProductA1() {}


ProductA2::ProductA2() {
    puts("ProductA2,," ) ;
}
ProductA2::~ProductA2() {}

ProductB1::ProductB1() {
    puts( "ProductB1$$" ) ;
}
ProductB1::~ProductB1(){}

ProductB2::ProductB2() {
    puts("ProductB2**" ) ;
}
ProductB2::~ProductB2() {}

#endif

/* FileName : 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() ;
} ;

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

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

#endif


/* FileName : AbstractFactory.cpp */

#ifndef _ABSTRACTFACTORY_CPP_
#define _ABSTRACTFACTORY_CPP_

#include "AbstractFactory.h"
#include "Product.h"

#include <cstdio>

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() ;
}

#endif

/*main.cpp*/
#include "AbstractFactory.h"

int main()
{
    AbstractFactory* ptr1 = new concreteFactory1() ;
    ptr1->createProductA() ;
    ptr1->createProductB() ;

    AbstractFactory* ptr2 = new concreteFactory2() ;
    ptr2->createProductA() ;
    ptr2->createProductB() ;

    return 0 ;
}


运行结果如下:
ProductA1..
ProductB1$$
ProductA2,,
ProductB2**