设计模式之--简单工厂模式

今天看《大话设计模式》，然后网上搜相关代码验证一下，看到了这篇博客：http://www.cnblogs.com/sdlypyzq/archive/2012/08/14/2637759.html，开头几句话甚得我心。

是啊，“衣带渐宽终不悔，为伊消得人憔悴”，那不就是我吗。

参考文章还有：http://blog.csdn.net/weiwenlongll/article/details/6918164

好了，下面是正文。

简单工厂模式：

简单工厂模式（Simple Factory Pattern)属于类的创新型模式，又叫静态工厂方法模式（Static Factory Method Pattern)，是通过专门定义一个类来负责创建其他类的实例，被创建的实例通常都具有共同的父类。

简单工厂模式的UML图：

简单工厂模式包含的角色及相应的职责如下：

工厂角色（Creator）：这是简单工厂模式的核心，由它负责创建所有的类的内部逻辑。当然工厂类必须能够被外部调用，创建所需的产品对象。

抽象产品角色（Product）：简单工厂模式所创建的所有对象的父类。注意这里的父类可以是接口也可以是抽像类，它负责描述所有实例锁共有的公共接口。

具体产品角色（Concreate Produce）：简单工厂所创建的具体实例对象，这些具体的产品往往都拥有共同的父类。

简单工厂模式理解：

简单工厂模式解决的问题是如何去实例化一个合适的对象。

简单工厂模式的核心思想就是：有一个类来负责创建实例的过程。具体来说，把产品看成一系列类的集合，这些类是由某个抽象类或者接口派生出来的一个对象树。而工厂类用来产生一个合适的对象来满足客户的要求。

   如果简单工厂模式所涉及到的具体产品之间没有共同的逻辑，那么我们就可以使用接口来扮演抽象产品的角色；如果具体产品之间有功能的逻辑或，我们就必须把这些共同的东西提取出来，放在一个抽象类中，然后让具体产品继承抽象类。为实现更好复用的目的，共同的东西总是应该抽象出来的。

下面举例一段代码，是《大话设计模式》一书中第一个例子：

.h文件：

#ifndef _FACTORY_H
#define _FACTORY_H

#include <assert.h>
#include <iostream>
#include <stdlib.h>

class operators {
public:
    void set_operator_nums(int num1, int num2) {
        num1_ = num1;
        num2_ = num2;
    }   
    virtual int get_result() = 0;
protected:
    int num1_;
    int num2_;
};

class operator_add : public operators {
public:
    int get_result() {
        return num1_ + num2_;
    }   
};

class operator_sub : public operators {
public:
    int get_result() {
        return num1_ - num2_;
    }   
};

class operation_factory {
public:
    static operators* get_operator(char ch){
        assert(ch == '+' || ch == '-');
        operators* oper = NULL;
        try {
            switch(ch){
                case '+':
                    oper = new operator_add;
                    break;
                case '-':
                    oper = new operator_sub;
                    break;
            }
        }
        catch(std::bad_alloc& e){
            std::cout<<e.what()<<std::endl;
            exit(1);
        }
        return oper;
    }
};

#endif

测试文件：

#include "factory.h"

#include <assert.h>
#include <iostream>
using namespace std;

int main()
{
    //operators op;   //error, abstruct class can not declare a object.
    
    char operate = '+';
    operators* oper = operation_factory::get_operator(operate);
    oper->set_operator_nums(3, 4); 
    int result = oper->get_result();
    assert(result == 7); 

    operate = '-';
    oper = operation_factory::get_operator(operate);
    oper->set_operator_nums(4, 3); 
    result = oper->get_result();
    assert(result == 1); 

    delete oper;
    return 0;
}

我们需要做一个具有加减功能的计算器。那我们就把加减操作提取出来封装成operator_add和operator_sub两个类，把它们共同逻辑操作数提取出来放在抽象类operators中，

使用了一个工厂类operation_factory来实例化我们需要的操作对象，operators获得子类的指针，这是多态的表现，然后调用指向子类的方法，获得计算结果。