• 设计模式-Factory


    定义

    工厂设计模式是一种创建型设计模式,它提供了一个用于创建对象的接口,但允许子类决定实例化哪个类。这种设计模式使一个类的实例化延迟到其子类。

    实现举例

    #include 
    #include 
    
    // 抽象产品类
    class Product {
    public:
        virtual void use() = 0;
    };
    
    // 具体产品类A
    class ConcreteProductA : public Product {
    public:
        void use() override {
            std::cout << "I'm using product A!" << std::endl;
        }
    };
    
    // 具体产品类B
    class ConcreteProductB : public Product {
    public:
        void use() override {
            std::cout << "I'm using product B!" << std::endl;
        }
    };
    
    // 工厂类
    class Factory {
    public:
        virtual Product* createProduct(std::string type) = 0;
    };
    
    // 具体工厂类A
    class ConcreteFactoryA : public Factory {
    public:
        ConcreteProductA* createProduct(std::string type) override {
            if (type == "A") {
                return new ConcreteProductA();
            } else {
                return nullptr;
            }
        }
    };
    
    // 具体工厂类B
    class ConcreteFactoryB : public Factory {
    public:
        ConcreteProductB* createProduct(std::string type) override {
            if (type == "B") {
                return new ConcreteProductB();
            } else {
                return nullptr;
            }
        }
    };
    
    int main() {
        // 使用具体工厂类A创建产品A
        ConcreteFactoryA* factoryA = new ConcreteFactoryA();
        ConcreteProductA* productA = dynamic_cast<ConcreteProductA*>(factoryA->createProduct("A"));
        if (productA != nullptr) {
            productA->use();
            delete productA; // 不要忘记删除产品对象!
        } else {
            std::cout << "Failed to create product A." << std::endl;
        }
        delete factoryA; // 不要忘记删除工厂对象!
    
        // 使用具体工厂类B创建产品B
        ConcreteFactoryB* factoryB = new ConcreteFactoryB();
        ConcreteProductB* productB = dynamic_cast<ConcreteProductB*>(factoryB->createProduct("B"));
        if (productB != nullptr) {
            productB->use();
            delete productB; // 不要忘记删除产品对象!
        } else {
            std::cout << "Failed to create product B." << std::endl;
        }
        delete factoryB; // 不要忘记删除工厂对象!
    
        return 0;
    }
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
    • 80

    总结

    工厂设计模式具有以下特性:

    1. 封装性:产品的实例化被封装在工厂类中,这可以避免产品被修改,从而保证产品的一致性。
    2. 扩展性:增加新产品时,只需增加一个工厂子类,不会违反开闭原则。
    3. 解耦:使用者只需要知道自己需要什么产品,而不需要关心产品具体的特性,从而降低了模块间的耦合。

    请注意,工厂设计模式也存在一些缺点,例如代码量可能会比较大,而且不利于扩展复杂的产品结构。

  • 相关阅读:
    链游:未来游戏发展的新风向
    torchvision.transforms 数据预处理:ToTensor()
    Redis—听说你速度跟甲斗一样快?——哨兵
    第2次实验:Ethernet
    蚁群算法ACO求解连续函数问题
    Spring Cloud 学习笔记(1 / 3)
    [HDLBits] Dualedge
    vue中插槽slot
    学习队列,Java实现
    👍SpringSecurity单体项目最佳实践
  • 原文地址:https://blog.csdn.net/scy518/article/details/134499152