C++实现设计模式之——工厂模式

适用范围：
需要创建大量不同对象，并且需要集中管理。例如你要买一辆汽车，你不必关心汽车的构造，以及汽车的创建过程，你只关心，你付钱给厂商，提需求，我需要一辆Golf，然后就是等待厂商交付车。汽车的零件的生产和组装全在工厂完成，这个时候，工厂就是一个集中生产和组装的中心，通过工厂来创建一辆汽车。

工厂模式有三种，分别是：

1. 简单工厂模式
2. 工厂方法模式
3. 抽象工厂模式

1.简单工厂模式

示例如下

template<typename T>
class ApplicationSingleTon
{
public:
    static T* getInstance() {
        if (_instance == nullptr) {
            _instance = new T();
        }
        return _instance;
    }
private:
    static T* _instance;
};
template <typename T>
T* ApplicationSingleTon<T>::_instance = nullptr;

class Product {
public:
    virtual void display() = 0;
};

class Engine : public Product
{
public:
    virtual void display()
    {
        cout << "create a engine"<<endl;
    }
};

class Wheel : public Product
{
public:
    virtual void display()
    {
        cout << "create a wheel"<<endl;
    }
};
enum CarMade
{
    CarMade_Engine = 0,
    CarMade_Whell
};
class Factory : public ApplicationSingleTon<Factory>
{
public:
    Product* create(CarMade type) {
        switch (type)
        {
        case CarMade_Engine:
            return new Engine();
            break;
        case CarMade_Whell:
            return new Wheel();
            break;
        default:
            break;
        }
    }
};

int main()
{
    Engine* eng;
    Wheel* wheel[3];
    //create engine
    eng = (Engine*)Factory::getInstance()->create(CarMade_Engine);
    eng->display();
    //create 4 wheel
    for (int i=0; i <4; i++)
    {
        wheel[i] = (Wheel*)Factory::getInstance()->create(CarMade_Whell);
        wheel[i]->display();
    }
    system("pause");
    return 0;
}

结合上一章节的单例模式，本示例使用了单例模式，工厂唯一，该工厂主要生产汽车，大家都知道汽车发动机和轮子组成。在工厂中，有一条生产线create（CarMade type），通过传入相应的指令type来决定生产什么零件，不需要手动去创建这些不同的零件。这里让Engine和Wheel类都继承自Product，是为了在create后，返回一个Product对象，然后在操作的时候对返回的Product强制转换成需要的对象。该示例完成说明了简单工厂的实现方式。简单工厂的缺点是，现在有这么一种情况，工厂现在收到上级要求，需要生产一种新的零件，我们假设为座椅。这个时候需要先在枚举中加入这种零件，然后在生产线中增加生产该零件的流程，是不是显得很繁琐，当后面生产的零件越来越多，后面扩展起来也就越来越差，于是就有了下面的实现方式

1.工厂方法模式

示例如下

class Factory
{
public:
    virtual Product* create() = 0;
};

class FactoryEngine : public Factory, public ApplicationSingleTon<FactoryEngine>
{
public:
    virtual Product* create() {
        return new Engine();
    }
};

class FactoryWheel : public Factory, public ApplicationSingleTon<FactoryWheel>
{
public:
    virtual Product* create() {
        return new Wheel();
    }
};
int main()
{
    Engine* eng;
    Wheel* wheel[3];
    //create engine
    eng = (Engine*)FactoryEngine::getInstance()->create();
    eng->display();
    //create 4 wheel
    for (int i=0; i <4; i++)
    {
        wheel[i] = (Wheel*)FactoryWheel::getInstance()->create();
        wheel[i]->display();
    }
    system("pause");
    return 0;
}

早期生产汽车零部件的工厂比较少，所以基本上一个汽车的所有零件都在汽车公司生产，这样一来就显得很不效率，慢慢的很多汽车厂商将汽车零部件的生产放到了其他的工厂去，这样，可能A公司生产发动机，B公司生产轮子。。。厂商就可以把重心放在装配上了。上述示例代码演示了这一模式。工厂抽象化，然后具体的生产零部件的工厂继承该抽象类，每个不同的工厂只需要关心自己所生产的零部件即可，即使其中一个零件工厂停止工作，也不会影响其他的工厂，换成简单工厂模式，只要流水线出现问题，整个工厂就崩溃了。将零件分拆成不同的工厂生产，方便后期扩展，例如这个时候，需要生产一个新的零件，只需要找个新的工厂即可，即使这个工厂流程上有问题，也不会影响到当前其他工厂流水线的正常工作。

可是像汽车的零件可能有非常的多，为每一个零件的生产新建一个工厂，可能不太现实，在管理起来也比较麻烦，资源上也比较浪费，于是就有了第三种模式

3.抽象工厂模式

抽象模式相对于工厂方法模式，其实就是在之前的工厂中新增一条流水线，例如之前生产发动机的厂商，现在新增了一条流水线用于生产变速箱，之前生产轮子的工厂，新增一条流水线用于生产方向盘。
示例如下

class Product {
public:
    virtual void display() = 0;
};

class Engine : public Product
{
public:
    virtual void display()
    {
        cout << "create a engine"<<endl;
    }
};

class Wheel : public Product
{
public:
    virtual void display()
    {
        cout << "create a wheel"<<endl;
    }
};

class Speed : public Product
{
public:
    virtual void display()
    {
        cout << "create a Transmission box" << endl;
    }
};
enum CarMade
{
    CarMade_Engine = 0,
    CarMade_Whell
};
class Factory
{
public:
    virtual Product* create() = 0;
    //新增生产变速箱
    virtual Product* createSpeed() = 0;
};

class FactoryEngine : public Factory, public ApplicationSingleTon<FactoryEngine>
{
public:
    virtual Product* create() {
        return new Engine();
    }
    virtual Product* createSpeed()
    {
        return new Speed();
    }
};

class FactoryWheel : public Factory, public ApplicationSingleTon<FactoryWheel>
{
public:
    virtual Product* create() {
        return new Wheel();
    }
    virtual Product* createSpeed()
    {
        return new Speed();
    }
};

至此，三种工厂模式的实现已经介绍完成，更多的还需要大家自己去理解，实现符合自己项目需要的模式。谢谢