设计模式的理会和实现(C++)之二-Abstract Factory模式

副标题#e#

浸染:

提供一个建设一系列相关或彼此依赖工具的接口，而无需指定它们详细的类。

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模式的利用.

#p#副标题#e#

实现:

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

#p#副标题#e#

2)AbstractFactory.cpp

#p#分页标题#e#

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

#p#副标题#e#

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