工厂模式包括三种：简单工厂模式、工厂方法模式、抽象工厂模式。

1. 简单工厂模式

设计思想：是用一个工厂来根据输入的条件产生不同的类，然后根据不同类的 virtual 函数得到不同的结果，只抽象产品，不抽象工厂

简单工厂模式的实质是由一个工厂类根据传入的参数，动态决定应该创建哪一类产品类(这些产品类继承自一个父类或接口)的实例。

打个比方，假设有一个工厂，他能生产出BENZ、BMW、AUDI三种汽车。当客户需要产品的时候一定要告诉工厂是哪种产品，是三种车型中的哪一种。当新增加一种新产品的时候，那么就要去修改工厂的类。

#include <iostream>
using namespace std;
// 汽车接口
class ICar
{
public:
    virtual string Name() = 0;  // 汽车名称
};
// 奔驰汽车
class BenzCar : public ICar
{
public:
    string Name() {
        return "Benz Car";
    }
};
// 宝马汽车
class BmwCar : public ICar
{
public:
    string Name() {
        return "Bmw Car";
    }
};
// 奥迪汽车
class AudiCar : public ICar
{
public:
    string Name() {
        return "Audi Car";
    }
};
// 工厂
class Factory
{
public:
    enum CAR_TYPE {
       BENZ_CAR,  // 奔驰汽车
       BMW_CAR,  // 宝马汽车
       AUDI_CAR  // 奥迪汽车
    };
    // 生产汽车
    ICar* CreateCar(CAR_TYPE type) {
        ICar *pCar = NULL;
        switch(type) {
        case CAR_TYPE::BENZ_CAR:
            pCar = new BenzCar();  // 奔驰汽车
            break;
        case CAR_TYPE::BMW_CAR:
            pCar = new BmwCar();  // 宝马汽车
            break;
        case CAR_TYPE::AUDI_CAR:
            pCar = new AudiCar();  // 奥迪汽车
            break;
        default:
            break;
        }
        return pCar;
    }
};
#define SAFE_DELETE(p) { if(p){delete(p); (p)=NULL;} }
int main()
{
    // 工厂
    Factory *pFactory = new Factory();
    // 奔驰汽车
    ICar *pCar = pFactory->CreateCar(Factory::BENZ_CAR);
    cout << pCar->Name() << endl;
    SAFE_DELETE(pCar);
    // 宝马汽车
    pCar = pFactory->CreateCar(Factory::BMW_CAR);
    cout << pCar->Name() << endl;
    SAFE_DELETE(pCar);
    // 奥迪汽车
    pCar = pFactory->CreateCar(Factory::AUDI_CAR);
    cout << pCar->Name() << endl;
    SAFE_DELETE(pCar);
    getchar();
    return 0;
}

2. 工厂方法模式

设计思想：不仅抽象产品，也抽象工厂，每一种产品都对应一个工厂

上面的简单工厂模式的缺点是当新增产品的时候就要去修改工厂的类，这就违反了开放封闭原则，(类、模块、函数)可以扩展，但是不可以修改，于是，就出现了工厂方法模式。所谓工厂方法模式，是指定义一个用于创建对象的接口，让子类决定实例化哪一个类。

打个比方，现在有BENZ、BMW、AUDI三种汽车产品需求，那么就开三个工厂。工厂BenzFactory负责生产BENZ汽车，工厂BmwFactory负责生产BMW，工厂AudiFactory负责生产AUDI汽车。这时候客户不需要告诉工厂生产哪种产品了，只需要告诉工厂生产就可以了。

#include <iostream>
using namespace std;
// 汽车接口
class ICar
{
public:
    virtual string Name() = 0;  // 汽车名称
};
// 奔驰汽车
class BenzCar : public ICar
{
public:
    string Name() {
        return "Benz Car";
    }
};
// 宝马汽车
class BmwCar : public ICar
{
public:
    string Name() {
        return "Bmw Car";
    }
};
// 奥迪汽车
class AudiCar : public ICar
{
public:
    string Name() {
        return "Audi Car";
    }
};
// 工厂接口
class AFactory
{
public:
    virtual ICar* CreateCar() = 0;  // 生产汽车
};
// 奔驰工厂
class BenzFactory : public AFactory
{
public:
    ICar* CreateCar() {
        return new BenzCar();
    }
};
// 宝马工厂
class BmwFactory : public AFactory
{
public:
    ICar* CreateCar() {
        return new BmwCar();
    }
};
// 奥迪工厂
class AudiFactory : public AFactory
{
public:
    ICar* CreateCar() {
        return new AudiCar();
    }
};
#define SAFE_DELETE(p) { if(p){delete(p); (p)=NULL;} }
int main()
{
    // 奔驰
    AFactory *pFactory = new BenzFactory();
    ICar *pCar = pFactory->CreateCar();
    cout << "Benz factory: " << pCar->Name() << endl;
    SAFE_DELETE(pCar);
    SAFE_DELETE(pFactory);
    // 宝马
    pFactory = new BmwFactory();
    pCar = pFactory->CreateCar();
    cout << "Bmw factory: " << pCar->Name() << endl;
    SAFE_DELETE(pCar);
    SAFE_DELETE(pFactory);
    // 奥迪
    pFactory = new AudiFactory();
    pCar = pFactory->CreateCar();
    cout << "Audi factory: " << pCar->Name() << endl;
    SAFE_DELETE(pCar);
    SAFE_DELETE(pFactory);
    getchar();
    return 0;
}

3. 抽象工厂模式

核心思想：与工厂方法类似，但是每个工厂可生产一个产品族（工厂方法算是一种极限情况下的抽象工厂，一个产品族下只有一个产品

　　为什么要有抽象工厂模式，假如我们AUDI产品中有Audi car和Audi bike两种产品，BENZ产品中有BENZ car和BENZ bike两种型号的厂品，BMW产品中有BMW car和BMW bike两种型号的厂品，那怎么办，上面两种工厂模式就不能解决了。这个时候抽象工厂模式就登场了。还是开设三家工厂，工厂AudiFactory负责生产Audi car和Audi bike两种型号产品，BENZ工厂负责生产Benz car和BENZ bike两种型号的产品，工厂BmwFactory生产Bmw car和Bwm bike两种产品。

#include <iostream>
using namespace std;
// 汽车接口
class ICar
{
public:
    virtual string Name() = 0;  // 汽车名称
};
// 自行车接口
class IBike
{
public:
    virtual string Name() = 0;  // 自行车名称
};
/********** 汽车 **********/
// 奔驰
class BenzCar : public ICar
{
public:
    string Name() {
        return "Benz Car";
    }
};
// 宝马
class BmwCar : public ICar
{
public:
    string Name() {
        return "Bmw Car";
    }
};
// 奥迪
class AudiCar : public ICar
{
public:
    std::string Name() {
        return "Audi Car";
    }
};
/********** 自行车 **********/
// 奔驰
class BenzBike : public IBike
{
public:
    string Name() {
        return "Benz Bike";
    }
};
// 宝马
class BmwBike : public IBike
{
public:
    string Name() {
        return "Bmw Bike";
    }
};
// 奥迪
class AudiBike : public IBike
{
public:
    string Name() {
        return "Audi Bike";
    }
};
工厂AudiFactory生产，
// 抽象工厂
class AFactory
{
public:
    enum FACTORY_TYPE {
        BENZ_FACTORY,  // 奔驰工厂
        BMW_FACTORY,  // 宝马工厂
        AUDI_FACTORY  // 奥迪工厂
    };
    virtual ICar* CreateCar() = 0;  // 生产汽车
    virtual IBike* CreateBike() = 0;    // 生产自行车
    static AFactory* CreateFactory(FACTORY_TYPE factory);  // 创建工厂
};
// 奔驰工厂
class BenzFactory : public AFactory
{
public:
    ICar* CreateCar() {
        return new BenzCar();
    }
    IBike* CreateBike() {
        return new BenzBike();
    }
};
// 宝马工厂
class BmwFactory : public AFactory
{
public:
    ICar* CreateCar() {
        return new BmwCar();
    }
    IBike* CreateBike() {
        return new BmwBike();
    }
};
// 奥迪工厂
class AudiFactory : public AFactory
{
public:
    ICar* CreateCar() {
        return new AudiCar();
    }
    IBike* CreateBike() {
        return new AudiBike();
    }
};
// 创建工厂
AFactory* AFactory::CreateFactory(FACTORY_TYPE factory)
{
    AFactory *pFactory = NULL;
    switch (factory) {
    case FACTORY_TYPE::BENZ_FACTORY:  // 奔驰工厂
        pFactory = new BenzFactory();
        break;
    case FACTORY_TYPE::BMW_FACTORY:  // 宝马工厂
        pFactory = new BmwFactory();
        break;
    case FACTORY_TYPE::AUDI_FACTORY:  // 奥迪工厂
        pFactory = new AudiFactory();
        break;
    default:
        break;
    }
    return pFactory;
}
#define SAFE_DELETE(p) { if(p){delete(p); (p)=NULL;} }
int main()
{
    // 奔驰
    AFactory *pFactory = AFactory::CreateFactory(AFactory::FACTORY_TYPE::BENZ_FACTORY);
    ICar *pCar = pFactory->CreateCar();
    IBike *pBike = pFactory->CreateBike();
    cout << "Benz factory - Car: " << pCar->Name() << endl;
    cout << "Benz factory - Bike: " << pBike->Name() << endl;
    SAFE_DELETE(pCar);
    SAFE_DELETE(pBike);
    SAFE_DELETE(pFactory);
    // 宝马
    pFactory = AFactory::CreateFactory(AFactory::FACTORY_TYPE::BMW_FACTORY);
    pCar = pFactory->CreateCar();
    pBike = pFactory->CreateBike();
    cout << "Bmw factory - Car: " << pCar->Name() << endl;
    cout << "Bmw factory - Bike: " << pBike->Name() << endl;
    SAFE_DELETE(pCar);
    SAFE_DELETE(pBike);
    SAFE_DELETE(pFactory);
    // 奥迪
    pFactory = AFactory::CreateFactory(AFactory::FACTORY_TYPE::AUDI_FACTORY);
    pCar = pFactory->CreateCar();
    pBike = pFactory->CreateBike();
    cout << "Audi factory - Car: " << pCar->Name() << endl;
    cout << "Audi factory - Bike: " << pBike->Name() << endl;
    SAFE_DELETE(pCar);
    SAFE_DELETE(pBike);
    SAFE_DELETE(pFactory);
    getchar();
    return 0;
}