创建型模式

       抽象工厂模式（Abstract Factory Pattern）是一种创建型设计模式，它提供一个接口，用于创建一系列相关或相互依赖的对象，而无需指定它们具体的类。

        简单说，它就像一个 "超级工厂"，可以生产一整套配套的产品，而不是单一产品。比如说GUI，在windows平台使用windows风格，mac使用mac风格。

为什么需要抽象工厂模式？

以电子设备工厂为例，我们可以清晰看到为什么需要抽象工厂模式：

1. 产品族管理：每个品牌（苹果、华为）都有一套配套产品（手机、电脑、平板），抽象工厂确保这些产品能协同工作（如生态互联）
2. 隔离具体实现：用户不需要知道 "iPhone 15" 的具体细节，只需知道 "这是苹果手机"
3. 轻松切换品牌：从苹果全家桶换成华为全家桶时，只需更换工厂，无需修改使用产品的代码
4. 符合开闭原则：新增小米工厂时，无需修改现有代码，只需实现新的工厂和产品

示例

        看代码是最好理解的方法。可以看到，这里是多个工厂，每个工厂对应多个不同的设备的。

#include <iostream>
#include <string>

// 抽象产品：手机
class Phone {
public:
    virtual ~Phone() = default;
    virtual std::string getName() const = 0;
};

// 抽象产品：电脑
class Computer {
public:
    virtual ~Computer() = default;
    virtual std::string getName() const = 0;
};

// 抽象产品：平板
class Tablet {
public:
    virtual ~Tablet() = default;
    virtual std::string getName() const = 0;
};

// 具体产品：苹果手机
class IPhone : public Phone {
public:
    std::string getName() const override {
        return "iPhone 15";
    }
};

// 具体产品：苹果电脑
class Mac : public Computer {
public:
    std::string getName() const override {
        return "MacBook Pro";
    }
};

// 具体产品：苹果平板
class IPad : public Tablet {
public:
    std::string getName() const override {
        return "iPad Pro";
    }
};

// 具体产品：华为手机
class HuaweiPhone : public Phone {
public:
    std::string getName() const override {
        return "Huawei Mate 60";
    }
};

// 具体产品：华为电脑
class HuaweiComputer : public Computer {
public:
    std::string getName() const override {
        return "Huawei MateBook X Pro";
    }
};

// 具体产品：华为平板
class HuaweiTablet : public Tablet {
public:
    std::string getName() const override {
        return "Huawei MatePad Pro";
    }
};

// 抽象工厂：电子设备工厂
class ElectronicFactory {
public:
    virtual ~ElectronicFactory() = default;
    virtual Phone* createPhone() const = 0;
    virtual Computer* createComputer() const = 0;
    virtual Tablet* createTablet() const = 0;
};

// 具体工厂：苹果工厂
class AppleFactory : public ElectronicFactory {
public:
    Phone* createPhone() const override {
        return new IPhone();
    }
    
    Computer* createComputer() const override {
        return new Mac();
    }
    
    Tablet* createTablet() const override {
        return new IPad();
    }
};

// 具体工厂：华为工厂
class HuaweiFactory : public ElectronicFactory {
public:
    Phone* createPhone() const override {
        return new HuaweiPhone();
    }
    
    Computer* createComputer() const override {
        return new HuaweiComputer();
    }
    
    Tablet* createTablet() const override {
        return new HuaweiTablet();
    }
};

// 客户端代码：使用电子设备
void useElectronicDevices(const ElectronicFactory& factory) {
    Phone* phone = factory.createPhone();
    Computer* computer = factory.createComputer();
    Tablet* tablet = factory.createTablet();
    
    std::cout << "使用的电子设备：" << std::endl;
    std::cout << "- 手机：" << phone->getName() << std::endl;
    std::cout << "- 电脑：" << computer->getName() << std::endl;
    std::cout << "- 平板：" << tablet->getName() << std::endl;
    
    delete phone;
    delete computer;
    delete tablet;
}

int main() {
    // 使用苹果设备
    std::cout << "=== 苹果生态 ===" << std::endl;
    AppleFactory appleFactory;
    useElectronicDevices(appleFactory);
    
    // 切换到华为设备，无需修改useElectronicDevices函数
    std::cout << "\n=== 华为生态 ===" << std::endl;
    HuaweiFactory huaweiFactory;
    useElectronicDevices(huaweiFactory);
    
    return 0;
}