C++一分钟之-设计模式：工厂模式与抽象工厂

在软件工程中，设计模式是一种通用的解决方案，用于解决常见的设计问题。工厂模式和抽象工厂模式是创建型设计模式中的两个重要成员，它们帮助我们创建对象而不需要暴露创建逻辑，同时使系统在不修改现有代码的情况下可以扩展。

工厂模式

工厂模式的核心思想是定义一个创建产品对象的接口，但是让子类决定实例化哪一个类。这样，工厂方法使一个类的实例化延迟到其子类。

常见问题与易错点

1. 过度使用：在不需要的地方使用工厂模式会导致代码复杂度增加，维护成本上升。
2. 违反开闭原则：当需要添加新产品时，可能需要修改现有的工厂类，这违反了“对扩展开放，对修改关闭”的原则。

如何避免

• 仅在需要动态选择具体实现或需要解耦创建过程时使用工厂模式。
• 使用抽象工厂模式来进一步封装创建过程，减少对工厂类的修改。

代码示例

#include <iostream>

// 抽象产品
class Product {
   
   
public:
    virtual void Operation() const = 0;
};

// 具体产品A
class ConcreteProductA : public Product {
   
   
public:
    void Operation() const override {
   
   
        std::cout << "ConcreteProductA operation." << std::endl;
    }
};

// 具体产品B
class ConcreteProductB : public Product {
   
   
public:
    void Operation() const override {
   
   
        std::cout << "ConcreteProductB operation." << std::endl;
    }
};

// 工厂
class Factory {
   
   
public:
    virtual Product* CreateProduct() = 0;
};

// 具体工厂A
class ConcreteFactoryA : public Factory {
   
   
public:
    Product* CreateProduct() override {
   
   
        return new ConcreteProductA();
    }
};

// 具体工厂B
class ConcreteFactoryB : public Factory {
   
   
public:
    Product* CreateProduct() override {
   
   
        return new ConcreteProductB();
    }
};

int main() {
   
   
    Factory* factory = new ConcreteFactoryA();
    Product* product = factory->CreateProduct();
    product->Operation();
    delete product;
    delete factory;
    return 0;
}

抽象工厂模式

抽象工厂模式提供了一个接口，用于创建一系列相关或相互依赖的对象，而无需指定它们具体的类。它比工厂模式更进一步，允许创建整个产品族。

常见问题与易错点

1. 过度抽象：如果产品族之间的关系并不紧密，过度使用抽象工厂可能导致不必要的复杂性。
2. 缺乏灵活性：一旦定义了产品族，很难在运行时更改或扩展。

如何避免

• 在产品族之间有明确的关系，并且需要一起创建时使用抽象工厂。
• 确保设计足够灵活，以便在不影响其他部分的情况下添加新的产品族。

代码示例

#include <iostream>

// 抽象产品A
class AbstractProductA {
   
   
public:
    virtual void InterfaceA() const = 0;
};

// 具体产品A1
class ConcreteProductA1 : public AbstractProductA {
   
   
public:
    void InterfaceA() const override {
   
   
        std::cout << "ConcreteProductA1 interface." << std::endl;
    }
};

// 具体产品A2
class ConcreteProductA2 : public AbstractProductA {
   
   
public:
    void InterfaceA() const override {
   
   
        std::cout << "ConcreteProductA2 interface." << std::endl;
    }
};

// 抽象产品B
class AbstractProductB {
   
   
public:
    virtual void InterfaceB() const = 0;
};

// 具体产品B1
class ConcreteProductB1 : public AbstractProductB {
   
   
public:
    void InterfaceB() const override {
   
   
        std::cout << "ConcreteProductB1 interface." << std::endl;
    }
};

// 具体产品B2
class ConcreteProductB2 : public AbstractProductB {
   
   
public:
    void InterfaceB() const override {
   
   
        std::cout << "ConcreteProductB2 interface." << std::endl;
    }
};

// 抽象工厂
class AbstractFactory {
   
   
public:
    virtual AbstractProductA* CreateProductA() = 0;
    virtual AbstractProductB* CreateProductB() = 0;
};

// 具体工厂1
class ConcreteFactory1 : public AbstractFactory {
   
   
public:
    AbstractProductA* CreateProductA() override {
   
   
        return new ConcreteProductA1();
    }
    AbstractProductB* CreateProductB() override {
   
   
        return new ConcreteProductB1();
    }
};

// 具体工厂2
class ConcreteFactory2 : public AbstractFactory {
   
   
public:
    AbstractProductA* CreateProductA() override {
   
   
        return new ConcreteProductA2();
    }
    AbstractProductB* CreateProductB() override {
   
   
        return new ConcreteProductB2();
    }
};

int main() {
   
   
    AbstractFactory* factory = new ConcreteFactory1();
    AbstractProductA* productA = factory->CreateProductA();
    AbstractProductB* productB = factory->CreateProductB();
    productA->InterfaceA();
    productB->InterfaceB();
    delete productA;
    delete productB;
    delete factory;
    return 0;
}

通过以上示例，我们可以看到工厂模式和抽象工厂模式如何帮助我们在C++中更好地管理对象的创建过程，同时保持代码的清晰和可维护性。