将须要的功用分红多个组件，可以削减代码的耦合性，进步代码复用。在今后对某个功用改需求时，只需部分修正，不至于牵一发而动全身，大大进步效力。
面向对象的设想头脑是经由历程封装、继续、多态把顺序的耦合度下降，而设想形式是对OOP的效力加成，合理应用设想形式可以使顺序越发天真，易于修正、复用。
然则，在辨别功用组件的同时也并非类越多越好，类的分别是为了封装，但分类的基本是笼统，具有雷同属性和功用的对象的笼统鸠合才是类。
在此，以完成一个具有加减乘除功用的计算器来申明简朴工场形式的完成和应用。
测试用例
[code]int main(){
//用户输入的两个操纵数和一个操纵符
double number1, number2;
char oper;
std::cout << "Please enter a binary operation expressions(+-*/):\n";
std::cin >> number1 >> oper >> number2;
//声明操纵对象
Operation<double> *operation = new Operation<double>;
//声明工场对象
Factory<double> factory;
//应用工场类挑选运算符并返回运算对象(加减照样乘或除?）
operation = factory.createOperate(oper);
//设置两个操纵数.（此处注重operation已经是详细的派生类运算，挪用setValue要领是继续自基类的）
operation->setValue(number1, number2);
if(operation != NULL){
//计算结果，此处现实挪用的是实行运算的派生类的getResult()要领。即基类指针指向派生类
double result = operation->getResult();
std::cout << "Result is: " << result << std::endl;
}else
std::cout << "Input is invalid!\n";//输入表达式不合法
return 0;
}
类的声明（.h）
[code]//简朴工场形式---完成一个计算器
#ifndef _01SIMPLEFACTORY_H_
#define _01SIMPLEFACTORY_H_
//基类， 运算类模板
template <typename T>
class Operation{
protected:
//被派生类继续并运用
T number1, number2;
public:
//计算结果
virtual T getResult();
//设置两个运算值
void setValue(T , T );
};
//派生类， 加法类
template <typename T>
class Add: public Operation<T>{
public:
//详细运算体式格局， 重写基类的要领
T getResult()override;
};
//派生类， 减法类
template <typename T>
class Sub: public Operation<T>{
public:
//详细运算体式格局， 重写基类的要领
T getResult()override;
};
//派生类， 乘法类
template <typename T>
class Mul: public Operation<T>{
public:
//详细运算体式格局， 重写基类的要领
T getResult()override;
};
//派生类， 除法类
template <typename T>
class Div: public Operation<T>{
public:
//详细运算体式格局， 重写基类的要领
T getResult()override;
};
//简朴工场类
template <typename T>
class Factory{
private:
Operation<T> *operate;
public:
//依据传入的操纵符，建立详细的运算类。返回运算类对象
Operation<T>* createOperate(const char &op);
};
#endif
类的完成(.cpp)
[code]#include "01SimpleFactory.h"
#include <iostream>
//类要领完成
template <typename T>
void Operation<T>::setValue(T v1, T v2){//设置两个运算值
number1 = v1;
number2 = v2;
}
template <typename T>
T Operation<T>::getResult(){
return 0;
}
template <typename T>
T Add<T>::getResult(){
T res = number1 + number2;
return res;
}
template <typename T>
T Sub<T>::getResult(){
T res = number1 - number2;
return res;
}
template <typename T>
T Mul<T>::getResult(){
T res = number1 * number2;
return res;
}
template <typename T>
T Div<T>::getResult(){
double res = 0;
//0不能作除数，可以作被除数
if(number2 != 0){
res = number1 / number2;
return res;
}
std::cout << "0 cannot be used as a divisor\n";
return 0;
}
//工场要领,即工场函数对其他操纵类依据功用挑选性的挪用
template <typename T>
Operation<T>* Factory<T>::createOperate(const char &op){
switch(op){
case '+':
operate = new Add<T>;
break;
case '-':
operate = new Sub<T>;
break;
case '*':
operate = new Mul<T>;
break;
case '/':
operate = new Div<T>;
break;
default:
operate = NULL;
break;
}
return operate;
}
以上就是简朴工场形式的完成。
总结：
建立型形式对类的实例化历程进行了笼统，可以将对象的建立与对象的运用历程星散。
简朴工场形式又称为静态工场要领形式，它属于类建立型形式。在简朴工场形式中，可以依据参数的差别返回差别类的实例。简朴工场形式特地定义一个类来担任建立其他类的实例，被建立的实例一般都具有配合的父类。
简朴工场形式包含三个角色：工场角色担任完成建立一切实例的内部逻辑；笼统产物角色是所建立的一切对象的父类，担任形貌一切实例所共有的大众接口；详细产物角色是建立目的，一切建立的对象都充任这个角色的某个详细类的实例。
简朴工场形式的要点在于：当你须要什么，只须要传入一个准确的参数，就可以猎取你所须要的对象，而无须晓得其建立细节。
简朴工场形式最大的长处在于完成对象的建立和对象的运用星散，将对象的建立交给特地的工场类担任，然则其最大的瑕玷在于工场类不够天真，增添新的详细产物须要修正工场类的推断逻辑代码，而且产物较多时，工场要领代码将会非常复杂。
简朴工场形式实用状况包含：工场类担任建立的对象比较少；客户端只晓得传入工场类的参数，关于怎样建立对象不关心。
以上就是C++设想形式浅识简朴工场形式的内容，更多相关内容请关注ki4网（www.ki4.cn）！
