《工厂模式（极简c++）》

        本文章属于专栏《设计模式（极简c++版）》

        继续上一篇《设计原则》。本章简要说明工厂模式。本文分为模式说明、本质思想、实践建议、代码示例四个部分。

• 模式说明：
  • 简单工厂模式
    • 方案：对象不直接new，而是通过另一个类（工厂）的接口生产
    • 优点：保证了创建行为的一致，降低维护成本
    • 缺点：所有对象在一个类中创建，修改影响面太大
  • 工厂方法模式
    • 方案：每个类有独立的工厂类
    • 优点：修改影响小
    • 缺点：工厂类太多，维护成本高
  • 抽象工厂模式
    • 方案：类似的工厂继承一个Base工厂
    • 优点：降低了工厂类的数量（本质是把有相同语义和行为的逻辑，放到Base工厂中，方便管理）
    • 缺点：对开发人员的业务理解要求高
• 本质思想：把类似的创建逻辑的封装在一个接口里、把有接口中类似的创建逻辑，再封装到更基础的接口或类中，以此类推。
• 实践建议：一个工厂生产所有类，当类变多时。增加工厂，每个工厂放有共性的类。当工厂太多时，把有共同行为的工厂逻辑，放到一个Base工厂中。每个阶段，只有到一定的量，才有类似可言，不要一开始盲目地封装，那会增加系统的复杂度，并降低可读性。

抽象工厂类代码示例：

#include <iostream>
#include <memory>

// 抽象产品 Bird
class Bird {
public:
    virtual void sound() = 0;
    virtual ~Bird() {} // 虚析构函数
};

// 具体产品 Sparrow
class Sparrow : public Bird {
public:
    void sound() override {
        std::cout << "Chirp chirp!" << std::endl;
    }
};

// 具体产品 Penguin
class Penguin : public Bird {
public:
    void sound() override {
        std::cout << "Squawk squawk!" << std::endl;
    }
};

// 抽象工厂 BirdFactory
class BirdFactory {
public:
    virtual std::unique_ptr<Bird> createBird() = 0;
    virtual ~BirdFactory() {} // 虚析构函数
};

// 具体工厂 SparrowFactory
class SparrowFactory : public BirdFactory {
public:
    std::unique_ptr<Bird> createBird() override {
        return std::unique_ptr<Bird>(new Sparrow());
    }
};

// 具体工厂 PenguinFactory
class PenguinFactory : public BirdFactory {
public:
    std::unique_ptr<Bird> createBird() override {
        return std::unique_ptr<Bird>(new Penguin());
    }
};

int main() {
    // 使用 SparrowFactory 创建 Sparrow 实例
    std::unique_ptr<BirdFactory> sparrowFactory(new SparrowFactory());
    std::unique_ptr<Bird> sparrow = sparrowFactory->createBird();
    sparrow->sound(); // 输出：Chirp chirp!

    // 使用 PenguinFactory 创建 Penguin 实例
    std::unique_ptr<BirdFactory> penguinFactory(new PenguinFactory());
    std::unique_ptr<Bird> penguin = penguinFactory->createBird();
    penguin->sound(); // 输出：Squawk squawk!

    return 0;
}