设计模式之简单工厂模式(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 }
测试输出如下:
简单工厂模式破坏了开放-封闭原则,当想添对象类型的时候,例如上例中想添加一个‘^’的运算,则需要添加一个乘方类并且需要修改简单工厂类。这是简单工工厂模式的一个缺点,因为我们最好遵循只添加不修改的原则,即开放-封闭原则。