设计模式-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. 解耦：使用者只需要知道自己需要什么产品，而不需要关心产品具体的特性，从而降低了模块间的耦合。

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