abstract factory模式

意图：提供一个创建一系列相关或者相互依赖对象的接口，而无需指定它们的具体的类。也就是协调对象的实例化。

ap_control有责任知道如何与合适的对象协同工作，resfactory有责任决定哪些对象是合适的。我可以使用不同的工作对象乃至只使用一个工作对象（用switch语句）。

使用到的策略：

1.发现并封装变化点

使用哪个驱动对象的选择是弯的，所以我将它封装在res_factory类中。

2.优先使用对象组合而不是类继承

将变化点放在一个独立的对象（res_factory对象）中并让ap_cotrol对象使用它，而不是拥有两类不同的ap_control对象。

3.针对接口设计而不是实现设计

ap_control知道怎么向res_factory请求实例化驱动对象，它不知道res_factory对象实际如何响应这一请求。

 

在工作模式中：

客户对象只知道向谁请求需要的对象 和如何使用这些对象

具体工厂指定哪 些对象被实例化。

抽象工厂类通过为每种不同类型的对象定义一个来指定哪些对象可以被实例化。

 

决定需要哪 个工作对象实际上是判断需要哪 系列的对象。

 

抽象工厂模式给了我们一种新的分解：根据责任分解：

1.谁在使用我们的对象  客户

2.谁来决定使用哪些特定的对象 工厂

 

 

UML结构图：

 

 

 

实现:
1)AbstractFactory.h

/**/ /* *******************************************************************
    created:    2006/07/19
    filename:     AbstractFactory.h
    author:        李创
                 http://www.cppblog.com/converse/

    purpose:    AbstractFactory的演示代码
******************************************************************** */

#ifndef ABSTRACTFACTORY_H
#define  ABSTRACTFACTORY_H

//  抽象基类AbstractProductA,代表产品A的抽象
class  AbstractProductA
{
public :
    AbstractProductA()  {}
     virtual   ~ AbstractProductA() {} ;
} ;

//  派生类ConcreateProductA1,继承自 AbstractProductA,代表产品A的第一种实现
class  ConcreateProductA1
    :  public  AbstractProductA
{
public :
    ConcreateProductA1();
     virtual   ~ ConcreateProductA1();
} ;

//  派生类ConcreateProductA2,继承自 AbstractProductA,代表产品A的第二种实现
class  ConcreateProductA2
    :  public  AbstractProductA
{
public :
    ConcreateProductA2();
     virtual   ~ ConcreateProductA2();
} ;

//  抽象基类AbstractProductB,代表产品B的抽象
class  AbstractProductB
{
public :
    AbstractProductB()  {}
     virtual   ~ AbstractProductB() {} ;
} ;

//  派生类ConcreateProductB1,继承自 AbstractProductB,代表产品B的第一种实现
class  ConcreateProductB1
    :  public  AbstractProductB
{
public :
    ConcreateProductB1();
     virtual   ~ ConcreateProductB1();
} ;

//  派生类ConcreateProductB2,继承自 AbstractProductB,代表产品B的第二种实现
class  ConcreateProductB2
    :  public  AbstractProductB
{
public :
    ConcreateProductB2();
     virtual   ~ ConcreateProductB2();
} ;

//  抽象基类AbstractFactory,工厂的抽象类,生产产品A和产品B
class  AbstractFactory
{
public :
    AbstractFactory() {}
     virtual   ~ AbstractFactory() {}

     virtual  AbstractProductA *  CreateProductA()  =   0 ;
     virtual  AbstractProductB *  CreateProductB()  =   0 ;
} ;

//  派生类ConcreateFactory1,继承自AbstractFactory
//  生产产品A和产品B的第一种实现
class  ConcreateFactory1
    :  public  AbstractFactory
{
public :
    ConcreateFactory1();
     virtual   ~ ConcreateFactory1();

     virtual  AbstractProductA *  CreateProductA();
     virtual  AbstractProductB *  CreateProductB();
} ;

//  派生类ConcreateFactory2,继承自AbstractFactory
//  生产产品A和产品B的第二种实现
class  ConcreateFactory2
    :  public  AbstractFactory
{
public :
    ConcreateFactory2();
     virtual   ~ ConcreateFactory2();

     virtual  AbstractProductA *  CreateProductA();
     virtual  AbstractProductB *  CreateProductB();
} ;

#endif

2)AbstractFactory.cpp

/**/ /* *******************************************************************
    created:    2006/07/19
    filename:     AbstractFactory.cpp
    author:        李创
                 http://www.cppblog.com/converse/

    purpose:    AbstractFactory的演示代码
******************************************************************** */

#include  < iostream >
#include  " AbstractFactory.h "

ConcreateProductA1::ConcreateProductA1()
{
    std::cout  <<   " construction of ConcreateProductA1/n " ;
}

ConcreateProductA1:: ~ ConcreateProductA1()
{
    std::cout  <<   " destruction of ConcreateProductA1/n " ;
}

ConcreateProductA2::ConcreateProductA2()
{
    std::cout  <<   " construction of ConcreateProductA2/n " ;
}

ConcreateProductA2:: ~ ConcreateProductA2()
{
    std::cout  <<   " destruction of ConcreateProductA2/n " ;
}

ConcreateProductB1::ConcreateProductB1()
{
    std::cout  <<   " construction of ConcreateProductB1/n " ;
}

ConcreateProductB1:: ~ ConcreateProductB1()
{
    std::cout  <<   " destruction of ConcreateProductB1/n " ;
}

ConcreateProductB2::ConcreateProductB2()
{
    std::cout  <<   " construction of ConcreateProductB2/n " ;
}

ConcreateProductB2:: ~ ConcreateProductB2()
{
    std::cout  <<   " destruction of ConcreateProductB2/n " ;
}

ConcreateFactory1::ConcreateFactory1()
{
    std::cout  <<   " construction of ConcreateFactory1/n " ;
}

ConcreateFactory1:: ~ ConcreateFactory1()
{
    std::cout  <<   " destruction of ConcreateFactory1/n " ;
}

AbstractProductA *  ConcreateFactory1::CreateProductA()
{
     return   new  ConcreateProductA1();
}

AbstractProductB *  ConcreateFactory1::CreateProductB()
{
     return   new  ConcreateProductB1();
}

ConcreateFactory2::ConcreateFactory2()
{
    std::cout  <<   " construction of ConcreateFactory2/n " ;
}

ConcreateFactory2:: ~ ConcreateFactory2()
{
    std::cout  <<   " destruction of ConcreateFactory2/n " ;
}

AbstractProductA *  ConcreateFactory2::CreateProductA()
{
     return   new  ConcreateProductA2();
}

AbstractProductB *  ConcreateFactory2::CreateProductB()
{
     return   new  ConcreateProductB2();
}

3)Main.cpp(测试代码)

/**/ /* *******************************************************************
    created:    2006/07/19
    filename:     Main.cpp
    author:        李创
                 http://www.cppblog.com/converse/

    purpose:    AbstractFactory的测试代码
******************************************************************** */

#include  " AbstractFactory.h "
#include  < stdlib.h >

int  main()
{
     //  生产产品A的第一种实现
    ConcreateFactory1  * pFactory1  =   new  ConcreateFactory1;
    AbstractProductA  * pProductA  =  pFactory1 -> CreateProductA();

     //  生产产品B的第二种实现
    ConcreateFactory2  * pFactory2  =   new  ConcreateFactory2;
    AbstractProductB  * pProductB  =  pFactory2 -> CreateProductB();

    delete pFactory1;
    delete pProductA;
    delete pFactory2;
    delete pProductB;

    system( " pause " );

     return   0 ;
}