简单工厂模式的C++实现

用简单工厂模式实现一个计算器类：

#include <iostream>
#include <string>

using namespace std;

class Operation
{
    public:
        Operation(double numA = 0, int numB = 0) : numberA(numA), numberB(numB)
        {
        }
        virtual ~Operation()
        {
            cout << "~Operation()" << endl;
        }
        virtual double GetResult()
        {
            double result = 0;
            return result;
        }
    protected:
        double numberA;
        double numberB;
};

class OperationAdd : public Operation
{
    public :
        OperationAdd(double numA = 0, int numB = 0) : Operation(numA, numB)
        {
        }
        virtual ~OperationAdd()
        {
            cout << "~OperationAdd()" << endl;
        }
        virtual double GetResult()
        {
            double result = 0;
            result = numberA + numberB;
            return result;
        }
};
class OperationSub : public Operation
{
    public :
        OperationSub(double numA = 0, int numB = 0) : Operation(numA, numB)
        {
        }
        virtual ~OperationSub()
        {
            cout << "~OperationSub()" << endl;
        }
        virtual double GetResult()
        {
            double result = 0;
            result = numberA - numberB;
            return result;
        }
};

class OperationFactory
{
    public :
        virtual ~OperationFactory()
        {    
        }
        static Operation* createOperate(double numA, double numB, char operate)
        {    
            Operation* oper;
            switch (operate)
            {
                case '+' :
                    oper = new OperationAdd(numA, numB);
                    break;
                case '-' :
                    oper = new OperationSub(numA, numB);
                    break;
                default :
                    oper = 0;
                    break;
            }
            return oper;
        }
};

int main()
{
    Operation* oper;
    oper = OperationFactory::createOperate(2, 3, '+');
    double result = oper->GetResult();
    cout << result << endl;
    delete oper;
    return 0;                                                                                                                                                                                                                                                                     
}

简单工厂模式的抽象实现：

#include <iostream>

using namespace std;

class Product
{
    public :
        Product()
        {
        }
        ~Product()
        {
        }
        virtual void CreateProduct()
        {
        }
    private :
        //
};

class ProductA : public Product
{
    public :
        ProductA() : Product()
        {
            cout << "ProductA()" << endl;
        }
        ~ProductA()
        {
            cout << "~ProductA()" << endl;
        }
        virtual void CreateProduct()
        {
        }
};

class ProductB : public Product
{
    public :
        ProductB() : Product()
        {
            cout << "ProductB()" << endl;
        }
        ~ProductB()
        {
            cout << "~ProductB()" << endl;
        }
        virtual void CreateProduct()
        {
        }
};

class SimpleFactory
{
    public :
        static Product* Create(int type)
        {
            //Product *prod;
            switch (type)
            {
                case 1:
                    prod = new ProductA; 
                    break;
                case 2:
                    prod = new ProductB;
                    break;
                default :
                    prod = 0;
            }
            return prod;
        }
        ~SimpleFactory()
        {
            delete prod;
        }
    private :
        static Product *prod;
};
Product* SimpleFactory::prod = 0;

int main()
{
    Product* prod;
    prod = SimpleFactory::Create(1);
    return 0;
}