C++抽象工厂模式详解与应用示例 —— 理解抽象工厂、工厂方法、简单工厂模式的区别

目录
1. **抽象工厂模式简介**
2. **抽象工厂模式的结构**
3. **抽象工厂模式示例代码**
4. **抽象工厂模式的优缺点**
5. **与简单工厂模式和工厂方法模式的区别**
6. **总结**

1. 抽象工厂模式简介

抽象工厂模式（Abstract Factory Pattern）是创建型设计模式之一，它用于创建一系列相关或相互依赖的对象。抽象工厂模式的核心思想是：定义一个接口或抽象类来创建相关的对象，而不指定具体类。使用这个模式，可以方便地生成特定对象的家族（如一种具体船体、引擎和武器的组合），避免了代码中直接引用具体类，并且有利于对象的解耦和拓展。

2. 抽象工厂模式的结构

抽象工厂模式包含以下几个角色：
- **抽象工厂（Abstract Factory）**：声明创建产品的接口，每个产品在这里有一个创建方法。
- **具体工厂（Concrete Factory）**：实现抽象工厂中的创建方法，生成具体的产品实例。
- **抽象产品（Abstract Product）**：定义产品的接口。
- **具体产品（Concrete Product）**：实现抽象产品的接口，由具体工厂创建。

通过这种模式，工厂对象生成的一系列对象可以确保相互兼容，便于扩展新的产品系列。

---

 3. 抽象工厂模式示例代码

以下示例实现一个抽象工厂模式：造船工厂根据需求生成不同种类的船体、引擎和武器组合的船。代码如下：

#include <iostream>
using namespace std;
//抽象工厂模式
class ShipBody //父类 船体
{
public:
	virtual void showBody() = 0;
	virtual ~ShipBody(){}
};

class WoodBody : public ShipBody //子类
{
public:
	void showBody() override
	{
		cout << "这是<木头>船体" << endl;
	}
	~WoodBody() 
	{
		cout << "WoodBody析构" << endl;
	}
};

class IronBody : public ShipBody //子类
{
public:
	void showBody() override
	{
		cout << "这是<铁制>船体" << endl;
	}
	~IronBody()
	{
		cout << "IronBody析构" << endl;
	}
};
class TiTanAlloyBody : public ShipBody //子类
{
public:
	void showBody() override
	{
		cout << "这是<钛合金>船体" << endl;
	}
	~TiTanAlloyBody()
	{
		cout << "TiTanAlloyBody析构" << endl;
	}
};
class ShipEngine //父类 引擎
{
public:
	virtual void showEngine() = 0;
	virtual ~ShipEngine(){} //虚析构，多态绑定
};

class ManPowerEngine : public ShipEngine //引擎 子类
{
public:
	void showEngine() override
	{
		cout << "这是<人力>引擎" << endl;
	}
	~ManPowerEngine()
	{
		cout << "ManPowerEngine析构" << endl;
	}
};

class MeChEngine : public ShipEngine //引擎 子类
{
public:
	void showEngine() override
	{
		cout << "这是<机械>引擎" << endl;
	}
	~MeChEngine()
	{
		cout << "MeChEngine析构" << endl;
	}
};

class NuclearEngine : public ShipEngine  //引擎 子类
{
public:
	void showEngine() override
	{
		cout << "这是<核动力>引擎" << endl;
	}
	~NuclearEngine()
	{
		cout << "NuclearEngine析构" << endl;
	}
};

class ShipWeapon //父类 武器
{
public:
	virtual void showWeapon() = 0;
	virtual ~ShipWeapon() {}
};

class GunWeapon : public ShipWeapon //武器 子类
{
public:
	void showWeapon() override
	{
		cout << "这是<燧发枪>武器" << endl;
	}
	~GunWeapon()
	{
		cout << "GunWeapon析构" << endl;
	}
};

class CannonWeapon : public ShipWeapon//武器 子类
{
public:
	void showWeapon() override
	{
		cout << "这是<火炮>武器" << endl;
	}
	~CannonWeapon()
	{
		cout << "CannonWeapon析构" << endl;
	}
};

class MissileWeapon : public ShipWeapon//武器 子类
{
public:
	void showWeapon() override
	{
		cout << "这是<导弹>武器" << endl;
	}
	~MissileWeapon()
	{
		cout << "MissileWeapon析构" << endl;
	}
};

class Ship //综合，船类。和船体、引擎、武器是组合关系
{
public:
	//由船体、引擎、武器组成
	Ship(ShipBody* body, ShipEngine* engine, ShipWeapon* weapon) 
		:body(body), engine(engine), weapon(weapon) 
	{

	}
	~Ship()
	{
		delete body;
		delete engine;
		delete weapon;
	}
	void showShip()
	{
		body->showBody();
		engine->showEngine();
		weapon->showWeapon();
	}
private:
	ShipBody* body;
	ShipEngine* engine;
	ShipWeapon* weapon;
};

class AbtractShipFactory //父类 抽象制船工厂
{
public:
	virtual Ship* createShip() = 0; //制船
	virtual~AbtractShipFactory(){}
};

class BacisShipFactory : public AbtractShipFactory //子类 小型船工厂
{
public:
	Ship* createShip() override
	{
		return new Ship(new WoodBody(), new ManPowerEngine(), new GunWeapon());//小型船
	}
	~BacisShipFactory()
	{
		cout << "BacisShipFactory析构" << endl;
	}
};

class StandardShipFactory : public AbtractShipFactory //子类 中型船工厂
{
public:
	Ship* createShip() override
	{
		return new Ship(new IronBody(), new MeChEngine(), new CannonWeapon());//中型船
	}
	~StandardShipFactory()
	{
		cout << "StandardShipFactory析构" << endl;
	}
};

class UltiMateShipFactory : public AbtractShipFactory //子类 大型船工厂
{
public:
	Ship* createShip() override
	{
		return new Ship(new TiTanAlloyBody(), new NuclearEngine(), new MissileWeapon());//大型船
	}
	~UltiMateShipFactory()
	{
		cout << "UltiMateShipFactory析构" << endl;
	}
};

int main()
{
	AbtractShipFactory* f = new BacisShipFactory(); //小型船工厂
	Ship* ship = f->createShip(); //制造小型船
	ship->showShip(); //展示小型船
	delete ship;
	delete f;

	f = new UltiMateShipFactory();
	ship = f->createShip();
	ship->showShip();
	delete ship;
	delete f;

	return 0;
}

使用抽象工厂，我们可以生成不同类型的船，而不依赖具体的实现，极大提高了代码的灵活性和可维护性。

---

4. 抽象工厂模式的优缺点

优点

- **易扩展性**：添加新产品家族时，只需添加新的具体工厂和产品类。
- **产品族一致**：确保同一产品族的对象能协同工作，避免了不兼容的产品组合。
  

缺点

- **类增多**：每新增一个产品族，都需要添加一系列类，可能增加系统复杂度。
- **复杂性增加**：抽象工厂模式的实现比简单工厂或工厂方法更复杂，需要更多的类结构。

---

5. 与简单工厂模式和工厂方法模式的区别

- **简单工厂模式（Simple Factory）**：通常通过一个工厂类的静态方法，根据参数返回相应的具体产品对象，但不属于真正的“设计模式”，通常用于简单的需求。
- **工厂方法模式（Factory Method）**：通过定义一个工厂接口并由子类实现特定的工厂，适用于创建单一类型的产品。
- **抽象工厂模式（Abstract Factory）**：与工厂方法类似，但更关注一组相关的产品，通过一个工厂来管理产品族的创建。

6. 总结

抽象工厂模式适用于创建一组相关或相互依赖的产品，而不指定具体类。它与简单工厂和工厂方法的核心区别在于：简单工厂和工厂方法偏重单一产品的创建，抽象工厂则着重于多个产品的组合关系。这种模式虽然增加了代码的复杂度，但它通过解耦工厂和产品的关系，使得代码更加灵活、可拓展。

7.b站设计模式课：设计模式 - 【C++版】_哔哩哔哩_bilibili