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

2024-07-14 09:19:46 浏览数 (1)

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

工厂模式

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

常见问题与易错点

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

如何避免

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

代码示例

代码语言:cpp复制
#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. 缺乏灵活性:一旦定义了产品族,很难在运行时更改或扩展。

如何避免

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

代码示例

代码语言:cpp复制
#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 中更好地管理对象的创建过程,同时保持代码的清晰和可维护性。

c++

0 人点赞