---

所谓工厂模式，就是指自己不直接创建对象，而是把创建对象的人物直接交给一个负责生产对象的工厂类。工厂模式属于创建型模式，大致可以分为三类，简单工厂模式、工厂方法模式、抽象工厂模式。

 

工厂模式可以分为三类：

1）简单工厂模式（Simple Factory）

2）工厂方法模式（Factory Method）

3）抽象工厂模式（Abstract Factory）

在《设计模式》一书中将工厂模式分为两类：工厂方法模式（Factory Method）与抽象工厂模式（Abstract Factory）。将简单工厂模式（Simple Factory）看为工厂方法模式的一种特例，两者归为一类。

三、区别

工厂方法模式：

一个抽象产品类，可以派生出多个具体产品类。  

一个抽象工厂类，可以派生出多个具体工厂类。  

每个具体工厂类只能创建一个具体产品类的实例。

抽象工厂模式：

多个抽象产品类，每个抽象产品类可以派生出多个具体产品类。  

一个抽象工厂类，可以派生出多个具体工厂类。  

每个具体工厂类可以创建多个具体产品类的实例。  

区别：

工厂方法模式只有一个抽象产品类，而抽象工厂模式有多个。  

工厂方法模式的具体工厂类只能创建一个具体产品类的实例，而抽象工厂模式可以创建多个。

两者皆可。

 

以生产汽车为例，假如要生产奔驰，宝马等汽车以及电动汽车，那么如何通过工厂模式来实现呢？

简单工厂模式：

工厂类中做判断，从而创造相应的产品。当增加新的产品时，就需要修改工厂类。

enum CTYPE {BENZ, BMW};  

class Car

{ 

public: 

    virtual void Print() = 0;

}; 

//Benz

class Benz: public Car

{ 

public: 

    void Show() { cout<<"Benz"<<endl; } 

}; 

//BMW

class Bmw: public Car 

{ 

public: 

    void Show() { cout<<"BMW"<<endl; } 

}; 

//唯一的工厂，可以生产两种型号的处理器核，在内部判断 

class Factory 

{ 

public:  

    Car * CreateCar(enum CTYPE ctype) 

    { 

        if(ctype == BENZ) //工厂内部判断 

            return new Benz(); //生产Benz 

        else if(ctype == BMW) 

            return new Bmw(); //生产Bmw 

        else 

            return NULL; 

    } 

};

 

工厂方法模式：

增加新的核类型时，就需要修改工厂类。这就违反了开放封闭原则：软件实体（类、模块、函数）可以扩展，但是不可修改。于是，工厂方法模式出现了。所谓工厂方法模式，是指定义一个用于创建对象的接口，让子类决定实例化哪一个类。Factory Method使一个类的实例化延迟到其子类。

 

class Car

{ 

public: 

    virtual void Show() = 0;

}; 

//Benz

class Benz: public Car

{ 

public: 

    void Show() { cout<<"Benz"<<endl; } 

}; 

//Bmw

class Bmw: public Car 

{ 

public: 

    void Show() { cout<<"Bmw"<<endl; } 

}; 

class Factory 

{ 

public: 

    virtual Car* CreateCar() = 0;

}; 

//生产Benz 

class FactoryA: public Factory 

{ 

public: 

    Benz* CreateCar() { return new Benz(); } 

}; 

//生产Bmw 

class FactoryB: public Factory 

{ 

public: 

    Bmw* CreateCar() { return new Bmw(); } 

}; 

 

工厂方法模式也有缺点，每增加一种产品，就需要增加一个对象的工厂。

 

抽象工厂模式

定义为提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。如果既需要生产奔驰和宝马的普通汽车，又需要生产电动汽车，那么工厂模式和工厂方法模式就不好使了，而应该使用抽象工厂模式。具体这样应用，这家公司还是开设两个工厂，一个专门用来生产A型号的产品，而另一个工厂专门用来生产B型号的产品

//普通车

class Car  

{ 

public: 

    virtual void Show() = 0;

}; 

class Benz: public Car   

{ 

public: 

    void Show() { cout<<"Benz"<<endl; } 

}; 

class Bmw :public Car 

{ 

public: 

    void Show() { cout<<"Bmw"<<endl; } 

}; 

//电动车

class ElectricCar   

{ 

public: 

    virtual void Show() = 0;

}; 

class EBenz : public ElectricCar   

{ 

public: 

    void Show() { cout<<"EBenz"<<endl; } 

 

}; 

class EBmw : public ElectricCar      

{ 

public: 

    void Show() { cout<<"EBmw"<<endl; } 

}; 

//工厂 

class CarFactory   

{ 

public: 

    virtual Car* CreateCar() = 0;

    virtual ElectricCar*  CreateElectricCar() = 0;

}; 

//工厂A

class FactoryA :public CarFactory 

{ 

public: 

    Car* CreateCar() { return new Benz(); } 

    ElectricCar* CreateElectricCar() { return new EBenz(); } 

}; 

//工厂B

class FactoryB : public CarFactory 

{ 

public: 

    Car* CreateCar() { return new Bmw(); } 

    ElectricCar* CreateElectricCar() { return new EBmw(); } 

};