设计模式-工厂模式

工厂模式主要有简单工厂模式、工厂方法模式和抽象工厂模式
简单个工厂模式：
比如要创建一个计算器实现加减乘除，就可以建立各种运算类，在通过一个工厂返回某个运算类的实例。
UML：

//抽象运算类
class Operation {  
public:
    virtual double GetResult(double A, double B) { return 0; }
};
//加法类
class OperationAdd :public Operation {
public:
    double GetResult(double A,double B)
    {
        return A + B;
    }
};
//减法类
class OperationSub :public Operation {
public:
    double GetResult(double A, double B)
    {
        return A - B;
    }
};
//乘法类
class OperationMul :public Operation {
public:
    double GetResult(double A, double B)
    {
        return A * B;
    }
};
//除法类
class OperationDiv :public Operation {
public:
    double GetResult(double A, double B)
    {
        if (B != 0)
            return A / B;
        else
            cout << "Error";
    }
};
enum TYPE { Add=0, Sub, Mul, Div };
//简单工厂类
class Factory {
public:
    static Operation *CreateOperation(TYPE type)
    {
        Operation* oper = NULL;
        switch (type)
        {
        case Add:
            oper = new OperationAdd();
            break;
        case Sub:
            oper = new OperationSub();
            break;
        case Mul:
            oper = new OperationMul();
            break;
        case Div:
            oper = new OperationDiv();
            break;
        }
        return oper;
    }
};
int main()
{
    Operation *oper = Factory::CreateOperation(Add);
    cout<<oper->GetResult(2,3);
    system("pause");
    return 0;
}

简单工厂模式在增加新的类型时，需要修改工厂类，违背了开放封闭原则。所以就出现了工厂方法模式。

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

简单来说就是每一个运算类通过各自的子工厂返回其实例，客户端直接使用子工厂。
UML：

前面部分一样，后面修改为

//抽象工厂类
class Factory {
public:
    virtual Operation *CreateOperation() = 0;
};
//加法工厂
class FactoryAdd :public Factory{
public:
    OperationAdd *CreateOperation()
    {
        return new OperationAdd();
    }
};
int main()
{
    Factory *Add = new FactoryAdd();
    Operation *oper = Add->CreateOperation();
    cout<<oper->GetResult(2,3);
    system("pause");
    return 0;
}

抽象工厂模式（Abstract Factory）：提供一个创建一系列相关或互相依赖对象的接口，而无需指定它们具体的类。

假设一家公司不仅可以生产单核处理器，也能生产多核处理器。这家公司开设两个工厂，一个专门用来生产A型号的单核多核处理器，而另一个工厂专门用来生产B型号的单核多核处理器。
UML：

//单核    
class SingleCore
{
public:
    virtual void Show() = 0;
};
class SingleCoreA : public SingleCore
{
public:
    void Show() { cout << "Single Core A" << endl; }
};
class SingleCoreB :public SingleCore
{
public:
    void Show() { cout << "Single Core B" << endl; }
};
//多核    
class MultiCore
{
public:
    virtual void Show() = 0;
};
class MultiCoreA : public MultiCore
{
public:
    void Show() { cout << "Multi Core A" << endl; }

};
class MultiCoreB : public MultiCore
{
public:
    void Show() { cout << "Multi Core B" << endl; }
};
//工厂    
class CoreFactory
{
public:
    virtual SingleCore* CreateSingleCore() = 0;
    virtual MultiCore* CreateMultiCore() = 0;
};
//工厂A，专门用来生产A型号的处理器    
class FactoryA :public CoreFactory
{
public:
    SingleCore* CreateSingleCore() { return new SingleCoreA(); }
    MultiCore* CreateMultiCore() { return new MultiCoreA(); }
};
//工厂B，专门用来生产B型号的处理器    
class FactoryB : public CoreFactory
{
public:
    SingleCore* CreateSingleCore() { return new SingleCoreB(); }
    MultiCore* CreateMultiCore() { return new MultiCoreB(); }
};
int main()
{
    FactoryA *A = new FactoryA();
    A->CreateSingleCore()->Show();
    FactoryB *B = new FactoryB();
    B->CreateMultiCore()->Show();
    system("pause");
    return 0;
}