设计模式-工厂模式

工厂模式分为三类：简单工厂模式、工厂方法模式、抽象工厂模式；

第一种：简单工厂模式

//简单工厂模式，缺点是：加入增加新的核类型时，就需要修改工厂类，这违反了开放封闭原则
enum CTYPE {COREA,COREB};
class singleCore
{
public:
    virtual viod show()=0;
};
class singleCoreA:public singleCore
{
public:
    void show(){cout<<"singleCoreA"}
};
class singleCoreB:public singleCore
{
public:
    void show(){cout<<"singleCoreB"}
};
class Factory
{
public:
    singleCore*createSingleCore(enum CTYPE ctype)
    {
        if(ctype==COREA)
            return new singleCoreA();
        else if(ctype==COREB)
            return new singleCoreB();
        else
            return NULL;
    }
};

第二类：工厂方法模式

所谓工厂方法模式：是指定义了一个用于创建对象的接口，让子类决定实例化那个类。Factory Method 使一个类的实例化延迟到其子类。工厂方法也有缺点：就需要增加一个对象的工厂，如果这家公司发展迅速，推出很多新的处理器核，那么就要开设相应的新工厂，就要定义一个个的工厂类。

enum CTYPE {COREA,COREB};
class singleCore
{
public:
    virtual viod show()=0;
};
class singleCoreA:public singleCore
{
public:
    void show(){cout<<"singleCoreA"}
};
class singleCoreB:public singleCore
{
public:
    void show(){cout<<"singleCoreB"}
};
class Factory
{
public:
    virtual singleCore*createSingleCore()=0;
};
class FactoryA{
public:
    singleCoreA*createSingleCore(){return new singleCoreA();}
};
classs FactoryB{
public:
    singleCoreB*createSingleCore(){return new singleCoreB();}
};

第三类：抽象工厂模式
举个例子，这家公司的技术不断进步，不仅可以生产单核处理器，也能生产多核处理器，之前的工厂模式和工厂方法模式无法解决，抽象模式可以解决，它的定义为提供了一个创建一系列相关或相互一栏对象的接口，而无需指定它们具体的类。具体的应用是：这家公司还是开设两个工厂，一个专门用来生产A型号的单核多核处理器，而另一个工厂专门用来生产B型号的单核多核处理器。

enum CTYPE {COREA,COREB};
class singleCore
{
public:
    virtual viod show()=0;
};
class singleCoreA:public singleCore
{
public:
    void show(){cout<<"singleCoreA";}
};
class singleCoreB:public singleCore
{
public:
    void show(){cout<<"singleCoreB";}
};
class MultiCore
{
public:
    virtual viod show()=0;
};
class multiCoreA:public MultiCore
{
public:
    void show(){cout<<"MultiCoreA";}
};
class multiCoreB:public MultiCore
{
public:
    void show(){cout<<"MultiCoreB";}
};
class Factory
{
public:
    virtual singleCore*createSingleCore()=0;
    virtual MultiCore*createMultiCore()=0;
};
class FactoryA{
public:
    singleCoreA*createSingleCore(){return new singleCoreA();}
    multiCoreA *createMultiCore(){return new multiCoreA();}
};
classs FactoryB{
public:
    singleCoreB*createSingleCore(){return new singleCoreB();}
    multiCoreB *createMultiCore(){return new multiCoreB();}
};