简单工厂模式、工厂模式、抽象工厂模式（含C++代码）

一、定义

尽可能用简洁的语言描述：
(1) 简单工厂模式：
  一个工厂，多个产品，产品需要有一个接口类。工厂类根据传入的参数，动态决定应该创建哪一类产品类，用产品基类指针指向实例化的产品并返回。
(2) 工厂模式：
  多个工厂，多个产品，产品和工厂各有一个接口类。工厂和产品一一对应，一个工厂只负责生产一种产品。工厂接口类中声明一个创建产品的纯虚函数，各具体工厂类需重写该方法。
(3) 抽象工厂模式：
  多个工厂，多个产品，每类产品又分为若干子系列，工厂有一个接口类，每一类产品都有自己的接口类，一个工厂可以生产多类不同的产品。
  举例：有Food和Car两类产品，每类产品都包含2个子系列A，B，故一共FoodA、FoodB、CarA、CarB四种，有两个工厂FactoryA、FactoryB，他们都能生产Food、Car两类产品，只不过FactoryA只生产FoodA和CarA，FactoryB只生产FoodB和CarB。工厂接口类中需声明创建产品的纯虚函数，有多少类产品，就有几个创建产品的纯虚函数。

具体可以看第二部分的代码演示，或者第三部分的参考文献。

---

二、代码演示

2.1 简单工厂模式

  代码示意：

#include <iostream>
using namespace std;

/*一个工厂，多个产品，产品需要一个产品接口类，工厂根据传入参数决定创建哪种产品，
 *违反开闭原则（可以在原始代码的基础上新增代码，但不可以修改原始代码）*/

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

class ProductA : public Product {
public:
    void show() {
        cout << "this is product A" << endl;
    }
};

class ProductB : public Product {
public:
    void show() {
        cout << "this is product B" << endl;
    }
};

class Factory {
public :
    Product *createProduct(int flag) {
        Product *res = nullptr;
        if (flag == 1) {
            res = new ProductA();
        } else {
            res = new ProductB();
        }
        return res;
    }
};

int main() {
    Factory *f = new Factory();
    Product *p = f->createProduct(2);
    p->show();
    return 0;
}

  代码解释：有A、B两类产品，没有工厂前，用户需要哪类产品，就需要自己new一个产品出来，现在有了工厂，把制作产品的逻辑放到工厂类中，用户通过传入参数告诉工厂制作哪一类产品(传入参数1，表示创建产品A，传入参数2，表示创建产品B，因此工厂类中含有很多if else语句，或者switch case语句)，工厂返回制作完成的产品。
  模式缺点：每新增或删除一个产品，都要修改工厂类的内部逻辑，违反开闭原则（可以在原始代码的基础上新增代码，但不可以修改原始代码逻辑）。

---

2.2 工厂模式

  代码示意：

#include <iostream>
using namespace std;

/*多个产品、多个工厂、产品和工厂各自都需要一个接口类，一个工厂负责生产一种产品
 *每新增一类产品，就需要新创建一个工厂类*/

// 产品
class Product {
public:
    virtual void show() = 0;
};

class ProductA : public Product {
public:
    void show() {
        cout << "this is product A" << endl;
    }
};

class ProductB : public Product {
public:
    void show() {
        cout << "this is product B" << endl;
    }
};

// 工厂
class Factory {
public :
    virtual Product *createProduct() = 0;
};

class FactoryA : public Factory {
public :
    Product *createProduct() {
        return new ProductA();
    }
};

class FactoryB : public Factory {
public :
    Product *createProduct() {
        return new ProductB();
    }
};

int main() {
    Factory *fa = new FactoryA();
    Factory *fb = new FactoryB();

    Product *pa = fa->createProduct();
    Product *pb = fb->createProduct();
    pa->show();
    pb->show();
    return 0;
}

  代码解释：有ProductA 、ProductA 两类产品，FactoryA 、FactoryB两个工厂，一个工厂负责生产一类产品，FactoryA 生产ProductA ，FactoryB 生产ProductB ，工厂的接口类中要定义创建产品的虚函数。
  模式缺点：：每新增一类产品，就需要新创建一个工厂类。

---

2.3 抽象工厂模式

  代码示意：

#include <iostream>
#include <vector>
#include <string>
using namespace std;

/*多类产品、多个工厂，每类产品包含若干子系列，每个工厂可以生产多类产品
 *(工厂接口类中声明创建不同产品的方法)，产品和工厂都需要接口类*/

// 第一类产品 Food
class Food {
public:
    virtual void show() = 0;
};

class FoodA : public Food {
public:
    void show() {
        cout << "this is food A" << endl;
    }
};

class FoodB : public Food {
public:
    void show() {
        cout << "this is food B" << endl;
    }
};

// 第一类产品 Car
class Car {
public:
    virtual void show() = 0;
};

class CarA : public Car {
public:
    void show() {
        cout << "this is car A" << endl;
    }
};

class CarB : public Car {
public:
    void show() {
        cout << "this is car B" << endl;
    }
};

// 工厂类
class Factory {
public :
    virtual Food *createFood() = 0;
    virtual Car *createCar() = 0;
};

class FactoryA : public Factory {
public :
    Food *createFood() {
        return new FoodA();
    }
    Car *createCar() {
        return new CarA();
    }
};

class FactoryB : public Factory {
public :
    Food *createFood() {
        return new FoodB();
    }
    Car *createCar() {
        return new CarB();
    }
};

int main() {
    Factory *fa = new FactoryA();
    fa->createFood()->show();
    fa->createCar()->show();

    Factory *fb = new FactoryB();
    fb->createFood()->show();
    fb->createCar()->show();

    return 0;
}

  代码解释：多类产品、多个工厂，每类产品包含若干子系列，每个工厂可以生产多类产品，工厂接口类中声明创建不同产品的方法)，产品和工厂都需要接口类。
  对应到代码中为：有Food和Car两类产品，每类产品包含A、B两个子系列，故有4类产品：FoodA、FoodB、CarA、CarB，有两个工厂FactoryA、FactoryB，其中FactoryA负责生产Food和Car的A系列产品，FactoryB负责生产Food和Car的B系列产品。

---

三、参考文献

(1) https://refactoringguru.cn/design-patterns/abstract-factory/cpp/example (代码写得好)
(2) https://blog.csdn.net/linwh8/article/details/51232834 （图画得好）
(3) https://developer.aliyun.com/article/761946 (代码和文字叙述的很好)