简单工厂模式 简单工厂

简单工厂

定义：定义一个用于创建对象的接口，让子类决定实例化哪一个类，工厂方法使一个类的实例化延迟到其子类。

        简单工厂模式的核心是，对于一个父类的多个继承子类，工厂对象的工厂函数根据用户输入，自动new出一个子类对象并返回其父类的指针，这样利用父类的指针执行父类的虚函数，就可以动态绑定子类的重写函数，从而实现多态。

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

类型：创建类模式

对于一个只拥有加减乘除运算的简单计算器，我们设计一个Operation的父类，并构造加减乘除四个类继承父类重写运算函数GetResult。然后定义工厂类中的工厂函数，其根据用户的输入new出相应的对象实例并返回其父类的指针。

类图：

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <iostream>
#include  <tr1/memory>

using namespace std;

class Operation
{
    private:
        double A, B;
    public:
        double GetA() const {return A;}
        double GetB() const {return B;}
        void SetA(double x) {A=x;}
        void SetB(double y) {B=y;}
        double virtual GetResult(){return 0;}
        Operation():A(0), B(0){}
};

class Add : public Operation
{
    public:
        double GetResult()
        {
            return GetA()+GetB();
        }
};

class Sub : public Operation
{
    public:
        double GetResult()
        {
            return GetA()-GetB();
        }
};

class Mul : public Operation
{
    public:
        double GetResult()
        {
            return GetA()*GetB();
        }
};

class Div : public Operation
{
    public:
        double GetResult()
        {
            return GetA()/GetB();
        }
};

class SimpleFactory
{
    public:
        static Operation * CreateOpeartor(char ch)
        {
            Operation * p;
            switch(ch)
            {
                case '+':
                    p = new Add();
                    break;
                case '-':
                    p = new Sub();
                    break;
                case '*':
                    p = new Mul();
                    break;
                case '/':
                    p = new Div();
                    break;
            }
            return p;
        }
};
        
int main(int argc, char *argv[])
{
    double A = 0;
    double B = 0;
    char ch = '\0';
    cin>>A>>ch>>B;

    tr1::shared_ptr<Operation> op(SimpleFactory::CreateOpeartor(ch));
    op->SetA(A);
    op->SetB(B);
    cout<<op->GetResult()<<endl;
}