C++设计模式浅识简单工厂模式

简单工厂定义： 实现一个工厂函数对其他操作类选择性的调用，实现用户的实际需求。

将需要的功能分成多个组件，可以减少代码的耦合性，提高代码复用。在以后对某个功能改需求时，只需局部修改，不至于牵一发而动全身，大大提高效率。

面向对象的设计思想是通过封装、继承、多态把程序的耦合度降低，而设计模式是对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++设计模式浅识简单工厂模式的内容，更多相关内容请关注PHP中文网（www.php.cn）！