02.工厂模式--Factory

原文地址：http://blog.csdn.net/jjunjoe/article/details/6623442

Factory模式：
Factory模式定义一个用于创建对象的接口，让子类决定实例化哪一个类。Factory模式使一个类的实例化延迟到其子类。

在面向对象系统设计中经常可以遇到以下的两类问题：
1） 为了提高内聚（Cohesion）和松耦合（Coupling），我们经常会抽象出一些类的公共接口以形成抽象基类或者接口。这样我们可以通过声明一个指向基类的指针来指向实际的子类实现，达到了多态的目的。
2） 还有一种情况就是在父类中并不知道具体要实例化哪一个具体的子类。

以上两个问题也就引出了Factory模式的两个最重要的功能：
1）定义创建对象的接口，封装了对象的创建；
2）使得具体化类的工作延迟到了子类中。

Factory模式的问题：
1. 每增加一个具体的Product，Factory就必须对它处理，这样Factory就永远不可能封闭了。
2. Factory模式仅仅局限于一类类（就是说Product是一类，有一个共同的基类），如果我们要为不同类的类提供一个对象创建的接口，那就要用AbstractFactory了。

Factory模式的结构图1：
 

Factory模式的结构图2：
 

以《大话设计模式》中的例子为代表，上面所说的Product就是数学运算。
Factory模式的实现代码：

// Factory.h

// 数学运算的基类
class Operator
{
protected:
 int m_iNumberA;
 int m_iNumberB;

public:
 virtual int GetResult()
 {
  return 0;
 }

 void SetOperatorNumber(int iNumberA, int iNumberB)
 {
  m_iNumberA = iNumberA;
  m_iNumberB = iNumberB;
 }
};

// 加法
class OperatorAdd : public Operator
{
 virtual int GetResult()
 {
  return m_iNumberA + m_iNumberB;
 }
};

// 减法
class OperatorSub : public Operator
{
 virtual int GetResult()
 {
  return m_iNumberA - m_iNumberB;
 }
};

// 乘法
class OperatorMul : public Operator
{
 virtual int GetResult()
 {
  return m_iNumberA * m_iNumberB;
 }
};

// 除法
class OperatorDiv : public Operator
{
 virtual int GetResult()
 {
  if ( m_iNumberB != 0 )
  {
   return m_iNumberA / m_iNumberB;
  }
  
  // 这里要加除数为0异常处理
  return 0;
 }
};


// 运算的工厂类
class OperatorFactory
{
public:
 static Operator* CreateOperator(char chOperator)
 {
  Operator* pOperator = NULL;

  switch( chOperator )
  {
  case '+':
   pOperator = new OperatorAdd();
   break;
  
  case '-':
   pOperator = new OperatorSub();
   break;
  
  case '*':
   pOperator = new OperatorMul();
      break;
  
  case '/':
   pOperator = new OperatorDiv();
      break;
  
  default:
      break;
  }

  return pOperator;
 }
};

// main.cpp

#include <iostream>
using namespace std;
#include "Factory.h"
void main()
{
 // 对于客户端来说，不需要知道具体的运算类的细节
 // 加
 Operator* pOpAdd = OperatorFactory::CreateOperator('+');
 pOpAdd->SetOperatorNumber(10, 5);
 cout << pOpAdd->GetResult() << endl;
 delete pOpAdd;
 pOpAdd = NULL;

 // 减
 Operator* pOpSub = OperatorFactory::CreateOperator('-');
 pOpSub->SetOperatorNumber(10, 5);
 cout << pOpSub->GetResult() << endl;
 delete pOpSub;
 pOpSub = NULL;

 // 乘
 Operator* pOpMul = OperatorFactory::CreateOperator('*');
 pOpMul->SetOperatorNumber(10, 5);
 cout << pOpMul->GetResult() << endl;
 delete pOpMul;
 pOpMul = NULL;

 // 除
 Operator* pOpDiv = OperatorFactory::CreateOperator('/');
 pOpDiv->SetOperatorNumber(10, 5);
 cout << pOpDiv->GetResult() << endl;
 delete pOpDiv;
 pOpDiv = NULL;
}