大话设计模式之抽象工厂模式

抽象工厂模式（Abstract Factory Pattern）是一种创建型设计模式，它提供了一种方式来创建一系列相关或依赖对象的家族，而无需指定其具体类。该模式通过提供一个抽象工厂接口，定义了一组可以创建不同类型对象的方法，具体的工厂类实现了这些方法以创建具体的对象。

#include <iostream>
#include <memory>

// 抽象产品A接口
class AbstractProductA {
public:
    virtual void use() = 0;
};

// 具体产品A1类
class ProductA1 : public AbstractProductA {
public:
    void use() override {
        std::cout << "Product A1 in use" << std::endl;
    }
};

// 具体产品A2类
class ProductA2 : public AbstractProductA {
public:
    void use() override {
        std::cout << "Product A2 in use" << std::endl;
    }
};

// 抽象产品B接口
class AbstractProductB {
public:
    virtual void eat() = 0;
};

// 具体产品B1类
class ProductB1 : public AbstractProductB {
public:
    void eat() override {
        std::cout << "Product B1 is eaten" << std::endl;
    }
};

// 具体产品B2类
class ProductB2 : public AbstractProductB {
public:
    void eat() override {
        std::cout << "Product B2 is eaten" << std::endl;
    }
};

// 抽象工厂接口
class AbstractFactory {
public:
    virtual std::shared_ptr<AbstractProductA> createProductA() = 0;
    virtual std::shared_ptr<AbstractProductB> createProductB() = 0;
};

// 具体工厂1类
class ConcreteFactory1 : public AbstractFactory {
public:
    std::shared_ptr<AbstractProductA> createProductA() override {
        return std::make_shared<ProductA1>();
    }

    std::shared_ptr<AbstractProductB> createProductB() override {
        return std::make_shared<ProductB1>();
    }
};

// 具体工厂2类
class ConcreteFactory2 : public AbstractFactory {
public:
    std::shared_ptr<AbstractProductA> createProductA() override {
        return std::make_shared<ProductA2>();
    }

    std::shared_ptr<AbstractProductB> createProductB() override {
        return std::make_shared<ProductB2>();
    }
};

int main() {
    // 创建具体工厂1对象
    std::shared_ptr<AbstractFactory> factory1 = std::make_shared<ConcreteFactory1>();

    // 使用工厂1创建产品A和产品B
    std::shared_ptr<AbstractProductA> productA1 = factory1->createProductA();
    std::shared_ptr<AbstractProductB> productB1 = factory1->createProductB();

    // 测试产品A1和产品B1
    productA1->use();
    productB1->eat();

    // 创建具体工厂2对象
    std::shared_ptr<AbstractFactory> factory2 = std::make_shared<ConcreteFactory2>();

    // 使用工厂2创建产品A和产品B
    std::shared_ptr<AbstractProductA> productA2 = factory2->createProductA();
    std::shared_ptr<AbstractProductB> productB2 = factory2->createProductB();

    // 测试产品A2和产品B2
    productA2->use();
    productB2->eat();

    return 0;
}

/*
在这个示例中，我们首先定义了两个抽象产品类 AbstractProductA 和 AbstractProductB，
它们分别有不同的具体实现类 ProductA1、ProductA2、ProductB1 和 ProductB2。
然后定义了一个抽象工厂类 AbstractFactory，包含了创建产品A和产品B的纯虚函数。
接着，我们创建了两个具体工厂类 ConcreteFactory1 和 ConcreteFactory2，
分别实现了抽象工厂类中的创建方法，用于创建具体的产品对象。

在 main 函数中，我们先创建了具体工厂1对象，然后使用该工厂对象分别创建了产品A1和产品B1，
并对其进行了测试。接着，创建了具体工厂2对象，使用工厂2创建了产品A2和产品B2，并测试了其功能。

通过抽象工厂模式，我们可以将产品的创建和使用分离，使得系统更易于扩展和维护。
同时，该模式也符合开闭原则，因为增加新的产品类型只需要添加新的具体产品类和对应的具体工厂类，
而无需修改现有的代码。

*/

觉得有帮助的话，打赏一下呗。。