设计模式(1)---简单工厂模式

　　在面向对象系统设计中经常可以遇到以下两类问题：

1. 为了提高内聚和松耦合，我们经常会抽象出一些类的公共接口以形成基类或接口。这样我们可以通过一个指向基类的指针来指向实际的子类实现，达到了多态的目的。这里很容易出现的一个问题就是一个太多子类继承于基类，我们不得不在每次要用到子类的地方就编写诸如 new ×××类似的代码。这里带来两个问题：A.客户程序员必须知道实际子类的名称；B.程序的扩展性和维护变得越来越困难
2. 还有一种情况就是在父类中并不知道具体要实例化哪一个具体的子类。这里的意思为：假设类A要使用到类B，B是一个抽象父类，在A中并不知道具体要实例化哪一个B的子类，但是在类A的子类D中是可以知道的。在A中我们没有办法直接使用类似于 new ×××，因为根本就不知道 ×××是什么。

　　以上两个问题也就引出了Factory模式的两个最重要功能：

1. 定义创建对象的接口，封装了对象的创建
2. 是的具体化类的工作延迟到了子类中

#include <memory>
#include <string>
#include <iostream>

using namespace std;

class Operation
{
public:
    Operation(double numberA = 0, double numberB = 0) :numberA_(numberA), numberB_(numberB)
    {}
    void setNumberA(double numberA)
    {
        numberA_ = numberA;
    }
    double getNumberA(void)
    {
        return numberA_;
    }
    void setNumberB(double numberB)
    {
        numberB_ = numberB;
    }
    double getNumberB(void)
    {
        return numberB_;
    }
    virtual double getResult(void) = 0;
protected:
    double numberA_;
    double numberB_;
};

class OperationAdd : public Operation
{
public:
    double getResult(void)
    {
        return numberA_ + numberB_;
    }
};

class OperationSub : public Operation
{
public:
    double getResult(void)
    {
        return numberA_ - numberB_;
    }
};

shared_ptr<Operation> createOperationFactory(char operate)
{
    switch (operate)
    {
    case '+':
        return make_shared<OperationAdd>();
    case '-':
        return make_shared<OperationSub>();
    default:
        cout << "can not distinguish the operate:" << operate << endl;
        return nullptr;
    }
}

int main()
{
    shared_ptr<Operation> operateAdd = createOperationFactory('+');
    if (nullptr == operateAdd)
    {
        return -1;
    }
    operateAdd->setNumberA(20.00);
    operateAdd->setNumberB(30.00);

    cout << operateAdd->getNumberA() << " + " << operateAdd->getNumberB() << " = " << operateAdd->getResult() << endl;
    return 0;
}