那谁的技术博客

感兴趣领域:高性能服务器编程,存储,算法,Linux内核
随笔 - 210, 文章 - 0, 评论 - 1183, 引用 - 0
数据加载中……

常见设计模式的解析和实现(C++)之二-Abstract Factory模式

作用:
提供一个创建一系列相关或相互依赖对象的接口,而无需指定它们具体的类。

UML结构图:


抽象基类:
1)ProductA,ProductB:分别代表不同类型的产品,而它们的派生类则是这种产品的一个实现.
2)AbstractFactory:生产这一系列产品的一个抽象工厂,它的派生类是不同的实现.

接口函数:
1)AbstractFactory::CreateProductA和AbstractFactory::CreateProductB:分别是生产不同产品的不同的实现,由各个派生出来的抽象工厂实现之.

解析:
Abstract Factory模式和Factory最大的差别就是抽象工厂创建的是一系列相关的对象,其中创建的实现其实采用的就是Factory模式的方法,对于某个实现的有一个派生出来的抽象工厂,另一个实现有另一个派生出来的工厂,等等.

可以举一个简单的例子来解释这个模式:比如,同样是鸡腿(ProductA)和汉堡(ProductB),它们都可以有商店出售(AbstractFactory),但是有不同的实现,有肯德基(ConcreateFactory1)和麦当劳(ConcreateFactory2)两家生产出来的不同风味的鸡腿和汉堡(也就是ProductA和ProductB的不同实现).
而负责生产汉堡和鸡腿的就是之前提过的Factory模式了.

抽象工厂需要特别注意的地方就是区分不同类型的产品和这些产品的不同实现.显而易见的,如果有n种产品同时有m中不同的实现,那么根据乘法原理可知有n*m个Factory模式的使用.


实现:
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;
}


posted on 2006-07-21 01:15 那谁 阅读(2431) 评论(2)  编辑 收藏 引用 所属分类: 设计模式

评论

# re: 常见设计模式的解析和实现(C++)之二-Abstract Factory模式   回复  更多评论   

写了不少代码,还是认真的嘛
2007-03-18 21:58 | 黄大仙

# re: 常见设计模式的解析和实现(C++)之二-Abstract Factory模式   回复  更多评论   

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;
}
2008-05-06 19:54 | overcomeunicom

只有注册用户登录后才能发表评论。
网站导航: 博客园   IT新闻   BlogJava   知识库   博问   管理