C++ 设计模式之简单工厂模式

设计模式之简单工厂模式（C++）
　　简单工厂模式，主要用于创建对象。新添加类时，不会影响以前的系统代码。核心思想是用一个工厂来根据输入的条件产生不同的类，然后根据不同类的virtual函数得到不同的结果。优点：适用于不同情况创建不同的类时。缺点：客户端必须要知道基类和工厂类，耦合性差。需要根据不同的需求创建不同的类。添加类的时候需要更爱工厂类。
以四则运算为例，其UML图如下：

 在客户端中给简单工厂类传递相关参数，工厂根据参数判断要create什么类型的对象，然后返回该对象。示例代码如下：

 1 // SimpleFactoryModel.h文件
 2 #pragma once
 3 
 4 // 操作基类
 5 template<typename T>
 6 class COperator
 7 {
 8 public:
 9     virtual T getResult() = 0;
10     virtual void setArgs(T lpa, T rpa);
11 protected:
12     T lah, rah;
13 };
14 
15 template<typename T>
16 void COperator<T>::setArgs(T lpa, T rpa)
17 {
18     lah = lpa;
19     rah = rpa;
20 }
21 // 加法类
22 template<typename T>
23 class CAddOperator : public COperator<T>
24 {
25 public:
26     virtual T getResult()
27     {
28         return COperator<T>::lah + COperator<T>::rah;
29     }
30 };
31 // 减法类
32 template<typename T>
33 class CSubOperator : public COperator<T>
34 {
35 public:
36     virtual T getResult()
37     {
38         return COperator<T>::lah - COperator<T>::rah;
39     }
40 };
41 // 乘法类
42 template<typename T>
43 class CMulOperator : public COperator<T>
44 {
45 public:
46     virtual T getResult()
47     {
48         return COperator<T>::lah * COperator<T>::rah;
49     }
50 };
51 // 除法类
52 template<typename T>
53 class CDivOperator : public COperator<T>
54 {
55 public:
56     virtual T getResult()
57     {
58         if (0 == COperator<T>::rah)
59         {
60             std::cout << "除数不能为0" << std::endl;
61             return 0;
62         }
63         return COperator<T>::lah / COperator<T>::rah;
64     }
65 };
66 // 工厂类
67 template<typename T>
68 class CCalculatorFactory
69 {
70 public:
71     static COperator<T> * createObject(char c);
72 };
73 
74 template<typename T>
75 COperator<T> * CCalculatorFactory<T>::createObject(char c)
76 {
77     COperator<T> * oper;
78     switch (c)
79     {
80     case '+':
81         oper = new CAddOperator<T>();
82         break;
83     case '-':
84         oper = new CSubOperator<T>();
85         break;
86     case '*':
87         oper = new CMulOperator<T>();
88         break;
89     case '/':
90         oper = new CDivOperator<T>();
91         break;
92     default:
93         oper = new CAddOperator<T>();
94         break;
95     }
96     return oper;
97 }

测试代码如下：

 1 #include <iostream>
 2 #include "SimpleFactoryModel.h"
 3 
 4 int main()
 5 {
 6     using namespace std;
 7     // 创建对象
 8     COperator<double> *p = CCalculatorFactory<double>::createObject('/');
 9     p->setArgs(23.23, 10.74);
10 
11     cout << p->getResult() << endl;
12     delete p;
13 
14     p = CCalculatorFactory<double>::createObject('+');
15     p->setArgs(23.23, 10.74);
16     cout << p->getResult() << endl;
17     delete p;
18 
19     p = CCalculatorFactory<double>::createObject('-');
20     p->setArgs(23.23, 10.74);
21     cout << p->getResult() << endl;
22     delete p;
23 
24     p = CCalculatorFactory<double>::createObject('*');
25     p->setArgs(23.23, 10.74);
26     cout << p->getResult() << endl;
27     delete p;
28 
29     getchar();
30     return 0;
31 
32     getchar();
33     return 0;
34 }

测试输出如下：

 　　简单工厂模式破坏了开放-封闭原则，当想添对象类型的时候，例如上例中想添加一个‘^’的运算，则需要添加一个乘方类并且需要修改简单工厂类。这是简单工工厂模式的一个缺点，因为我们最好遵循只添加不修改的原则，即开放-封闭原则。