C++简单工厂的代码实现

简单工厂模式的核心思想是把创建对象过程和对象本身业务处理分离，工厂处理创建对象的细节。

具体实现代码：

#include <iostream>

using namespace std;
//1 定义一个操作接口
class Operation
{
public:
    virtual double GetResult(double a, double b) = 0;
};

//2 定义具体操作类
class OperationAdd : public Operation
{
public:
    virtual double GetResult(double a, double b)
    {
        return a + b;
    }
};

class OperationSub : public Operation
{
public:
    virtual double GetResult(double a, double b)
    {
        return a - b;
    }
};
class OperationMul : public Operation
{
public:
    virtual double GetResult(double a, double b)
    {
        return a * b;
    }
};
class OperationDiv : public Operation
{
public:
    virtual double GetResult(double a, double b)
    {
        if (b == 0) {
            cout << "除数不能为0";
            return -1;
        }
        return a / b;
    }
};

//3 定义简单工厂类
class OperationFactory
{
public:
    virtual Operation* createOperation(char operate)
    {
        Operation* op = NULL;
        switch (operate)
        {
        case '+':
        {
            op = new OperationAdd();
        }
        break;
        case '-':
        {
            op = new OperationSub();
        }
        break;
        case '*':
        {
            op = new OperationMul();
        }
        break;
        case '/':
        {
            op = new OperationDiv();
        }
        break;
        default:
            break;
        }
        return op;
    }
};

//静态方法定义
//class OperationFactory
//{
//public:
//    static Operation* createOperation(char operate)
//    {
//        Operation* op = NULL;
//        switch (operate)
//        {
//        case '+':
//        {
//            op = new OperationAdd();
//        }
//        break;
//        case '-':
//        {
//            op = new OperationSub();
//        }
//        break;
//        case '*':
//        {
//            op = new OperationMul();
//        }
//        break;
//        case '/':
//        {
//            op = new OperationDiv();
//        }
//        break;
//        default:
//            break;
//        }
//        return op;
//    }
//};

//用户端接口类
class calculator
{
public:
    calculator(OperationFactory* factory)
    {
        mFactory = factory;
    }

    double operate(double a, double b, char operate)
    {
        Operation* op = mFactory->createOperation(operate);
        return op->GetResult(a, b);
    }
private:
    OperationFactory* mFactory;
};
int main()
{
    //实例化调用
    calculator cl(new OperationFactory);
    std::cout << cl.operate(1, 5, '+');
    //静态工厂
    /*COperation* op = OperationFactory::createOperation('+');
    std::cout << op->GetResult(1, 5);*/
}

我们无需提供具体的子类类名，只需要提供一个类型(type)即可得到相应的实例对象。这样的话，当子类的类名更换或者增加子类时我们都无需修改客户端代码，只需要在简单工厂类上增加一个分支判断代码即可。

缺点：

该模式使得工厂的负担过重，而且每次添加新产品，都需要修改工厂，不是很符合开闭原则，但是比直接在业务逻辑里添加要好很多了。