【设计模式】——简单工厂模式（Simple Factory Pattern）

目录

引言

一、简单工厂模式的基本概念

核心思想

简单工厂模式结构

UML图

应用场景

二、简单工厂模式的优点与缺点

优点

缺点

三、C++实现简单工厂模式

抽象产品类

工厂类

客户端代码

总代码

四、结论

---

引言

在软件开发中，设计模式是一种被反复使用、多数人知晓、经过分类编目的、代码设计经验的总结。它们可以解决特定情境下的问题，并提供一种通用的解决方案。其中，简单工厂模式（Simple Factory Pattern）是一种常用的创建型设计模式，它通过封装对象的创建逻辑来降低客户端与具体产品类之间的耦合度，提高系统的灵活性和可扩展性。本文将详细介绍简单工厂模式在C++的应用。

一、简单工厂模式的基本概念

简单工厂模式又称为静态工厂方法模式，它定义了一个工厂类，这个类根据传入的参数不同返回不同类的实例。这些实例通常都具有共同的父类或接口。简单工厂模式的核心在于将对象的创建逻辑封装在工厂类中，客户端通过调用工厂类的静态方法来获取所需的对象，而无需直接实例化具体产品类。

核心思想

1. 封装：将对象的创建逻辑封装在工厂类中，客户端不需要知道具体对象的创建细节。
2. 解耦：通过引入一个共同的接口，客户端代码与具体的产品类解耦，增加了系统的灵活性和可扩展性。
3. 单一职责原则：工厂类负责创建所有实例，符合单一职责原则。

简单工厂模式结构

简单工厂模式通常由以下三部分组成：

1. 工厂类（Creator）：这是简单工厂模式的核心，负责创建具体产品的实例。
2. 抽象产品（Product）：所有具体产品类的共同接口或基类，定义了产品的规范。
3. 具体产品（Concrete Product）：实现了抽象产品接口或继承了抽象产品类的具体产品。

UML图

应用场景

• 当系统中有多个产品类，这些产品类之间具有共同的接口或抽象类时。
• 客户端需要创建这些产品的实例，但客户端不依赖于具体的产品类。
• 系统需要扩展时，增加新的产品类，而不需要修改工厂类的代码。

二、简单工厂模式的优点与缺点

优点

1. 降低耦合度：客户端与具体产品类解耦，客户端只需通过工厂类获取所需对象，无需直接实例化具体产品类。
2. 易于扩展：当需要新增产品类型时，只需修改工厂类的代码，无需修改客户端代码。
3. 简化客户端代码：客户端只需知道产品的类型，而无需关心具体的创建细节。

缺点

1. 违反开闭原则：新增产品类型时需要修改工厂类，不符合开闭原则（对扩展开放，对修改关闭）。
2. 工厂类职责过重：随着产品类型的增多，工厂类的代码会变得越来越复杂。

三、C++实现简单工厂模式

下面是一个用C++实现的简单工厂模式的示例，我们将创建一个简单的汽车工厂，用于生产不同类型的汽车。

抽象产品类

首先，定义一个汽车的抽象基类Car，它包含一个纯虚函数show用于展示汽车的信息。

// 抽象汽车类
class Car {
public:
    virtual void show() = 0;
    virtual ~Car() {}
};

// 具体产品类继承-->抽象产品类，并对它的方法进行重写操作

// 宝马
class Bmw : public Car {
public:
    void show() override {
        std::cout << "这是一辆宝马汽车！" << std::endl;
    }
};

// 奥迪
class Audi : public Car {
public:
    void show() override {
        std::cout << "这是一辆奥迪汽车！" << std::endl;
    }
};

工厂类

然后，定义一个CarFactory类，该类包含一个静态方法createCar，根据传入的类型参数返回不同类型的汽车实例。

// 通过传递参数来确定生成哪类汽车
// 汽车工厂类
class CarFactory {
public:
    enum CarType { BMW, AUDI };

    static Car* createCar(CarType type) {
        switch (type) {
        case BMW:
            return new Bmw();
        case AUDI:
            return new Audi();
        default:
            return nullptr;
        }
    }
};

客户端代码

最后，在客户端代码中，我们只需要根据需求调用CarFactory的createCar方法即可创建不同类型的汽车实例。

int main() {  
    Car* bmw = CarFactory::createCar(CarFactory::BMW);  
    if (bmw != nullptr) {  
        bmw->show();  
        delete bmw;  
    }  
  
    Car* audi = CarFactory::createCar(CarFactory::AUDI);  
    if (audi != nullptr) {  
        audi->show();  
        delete audi;  
    }  
  
    return 0;  
}

总代码

#include <iostream>
#include <string>


// 抽象汽车类
class Car {
public:
    virtual void show() = 0;
    virtual ~Car() {}
};

// 具体产品类继承-->抽象产品类，并对它的方法进行重写操作

// 宝马
class Bmw : public Car {
public:
    void show() override {
        std::cout << "这是一辆宝马汽车！" << std::endl;
    }
};

// 奥迪
class Audi : public Car {
public:
    void show() override {
        std::cout << "这是一辆奥迪汽车！" << std::endl;
    }
};

// 通过传递参数来确定生成哪类汽车
// 汽车工厂类
class CarFactory {
public:
    enum CarType { BMW, AUDI };

    static Car* createCar(CarType type) {
        switch (type) {
        case BMW:
            return new Bmw();
        case AUDI:
            return new Audi();
        default:
            return nullptr;
        }
    }
};

int main() {
    Car* bmw = CarFactory::createCar(CarFactory::BMW);
    if (bmw != nullptr) {
        bmw->show();
        delete bmw;
    }

    Car* audi = CarFactory::createCar(CarFactory::AUDI);
    if (audi != nullptr) {
        audi->show();
        delete audi;
    }

    return 0;
}

四、结论

简单工厂模式通过提供一个统一的接口来创建不同类型的对象，降低了客户端与具体产品类的耦合度，提高了系统的灵活性和可维护性。然而，由于所有产品的创建逻辑都集中在工厂类中，当需要添加新产品时，可能需要修改工厂类，这在一定程度上违背了开闭原则。因此，在决定使用简单工厂模式时，需要根据实际项目的需求和规模进行权衡。