当前位置：首页 > news >正文

工厂模式 - 工厂方法模式、抽象工厂模式

news 2025/7/14 4:07:31

引言

工厂模式（Factory Pattern）是设计模式中创建型模式的一种，它提供了一种创建对象的最佳方式。工厂模式的核心思想是将对象的创建与使用分离，使得代码更加灵活、可扩展。工厂模式主要分为两种：工厂方法模式和抽象工厂模式。

本文将详细介绍工厂方法模式和抽象工厂模式的概念、实现方式以及在C++中的应用。

工厂方法模式

概念

工厂方法模式（Factory Method Pattern）定义了一个创建对象的接口，但由子类决定要实例化的类是哪一个。工厂方法模式让类的实例化推迟到子类。

优点

解耦：将对象的创建与使用分离，降低代码的耦合度。
扩展性好：新增产品类时，只需增加相应的工厂类，无需修改现有代码。
符合开闭原则：对扩展开放，对修改关闭。

缺点

类的数量增加：每增加一个产品类，就需要增加一个对应的工厂类，导致类的数量增加。
复杂性增加：对于简单的对象创建，使用工厂方法模式可能会增加代码的复杂性。

实现

下面是一个简单的工厂方法模式的实现示例：

#include <iostream>
#include <string>// 产品接口
class Product {
public:virtual ~Product() {}virtual void use() = 0;
};// 具体产品A
class ProductA : public Product {
public:void use() override {std::cout << "Using Product A" << std::endl;}
};// 具体产品B
class ProductB : public Product {
public:void use() override {std::cout << "Using Product B" << std::endl;}
};// 工厂接口
class Factory {
public:virtual ~Factory() {}virtual Product* createProduct() = 0;
};// 具体工厂A
class FactoryA : public Factory {
public:Product* createProduct() override {return new ProductA();}
};// 具体工厂B
class FactoryB : public Factory {
public:Product* createProduct() override {return new ProductB();}
};int main() {Factory* factoryA = new FactoryA();Product* productA = factoryA->createProduct();productA->use();Factory* factoryB = new FactoryB();Product* productB = factoryB->createProduct();productB->use();delete productA;delete productB;delete factoryA;delete factoryB;return 0;
}

应用场景

工厂方法模式适用于以下场景：

不确定对象的类型：当创建对象时，不确定具体要创建哪种类型的对象。
需要扩展：当需要扩展系统，增加新的产品类时，使用工厂方法模式可以避免修改现有代码。

抽象工厂模式

概念

抽象工厂模式（Abstract Factory Pattern）提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。抽象工厂模式是工厂方法模式的扩展，它用于创建一组相关的对象。

优点

高内聚：将相关的产品族集中在一起创建，保证产品族的一致性。
解耦：将产品的创建与使用分离，降低代码的耦合度。
符合开闭原则：对扩展开放，对修改关闭。

缺点

类的数量增加：每增加一个产品族，就需要增加一个对应的工厂类，导致类的数量增加。
复杂性增加：对于简单的对象创建，使用抽象工厂模式可能会增加代码的复杂性。

实现

下面是一个简单的抽象工厂模式的实现示例：

#include <iostream>
#include <string>// 抽象产品A
class AbstractProductA {
public:virtual ~AbstractProductA() {}virtual void use() = 0;
};// 具体产品A1
class ProductA1 : public AbstractProductA {
public:void use() override {std::cout << "Using Product A1" << std::endl;}
};// 具体产品A2
class ProductA2 : public AbstractProductA {
public:void use() override {std::cout << "Using Product A2" << std::endl;}
};// 抽象产品B
class AbstractProductB {
public:virtual ~AbstractProductB() {}virtual void use() = 0;
};// 具体产品B1
class ProductB1 : public AbstractProductB {
public:void use() override {std::cout << "Using Product B1" << std::endl;}
};// 具体产品B2
class ProductB2 : public AbstractProductB {
public:void use() override {std::cout << "Using Product B2" << std::endl;}
};// 抽象工厂
class AbstractFactory {
public:virtual ~AbstractFactory() {}virtual AbstractProductA* createProductA() = 0;virtual AbstractProductB* createProductB() = 0;
};// 具体工厂1
class ConcreteFactory1 : public AbstractFactory {
public:AbstractProductA* createProductA() override {return new ProductA1();}AbstractProductB* createProductB() override {return new ProductB1();}
};// 具体工厂2
class ConcreteFactory2 : public AbstractFactory {
public:AbstractProductA* createProductA() override {return new ProductA2();}AbstractProductB* createProductB() override {return new ProductB2();}
};int main() {AbstractFactory* factory1 = new ConcreteFactory1();AbstractProductA* productA1 = factory1->createProductA();AbstractProductB* productB1 = factory1->createProductB();productA1->use();productB1->use();AbstractFactory* factory2 = new ConcreteFactory2();AbstractProductA* productA2 = factory2->createProductA();AbstractProductB* productB2 = factory2->createProductB();productA2->use();productB2->use();delete productA1;delete productB1;delete factory1;delete productA2;delete productB2;delete factory2;return 0;
}