一、定义
尽可能用简洁的语言描述：
(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
(代码和文字叙述的很好)