设计模式 之 工厂模式（简单工厂模式、工厂方法模式、抽象工厂模式）（C++）

C++ 工厂模式

引言

在 C++ 编程中，对象的创建是一个常见且基础的操作。然而，当项目规模逐渐增大，对象的创建逻辑变得复杂时，直接在代码中使用 new 关键字创建对象会带来诸多问题，比如代码的可维护性变差、难以扩展等。工厂模式应运而生，它为对象的创建提供了一种更加灵活、可扩展的解决方案。本文将详细介绍 C++ 中的工厂模式，包括简单工厂模式、工厂方法模式和抽象工厂模式，并通过具体的例子帮助大家理解。

一、简单工厂模式

概念

简单工厂模式是工厂模式的基础版本，它定义了一个工厂类，该类可以根据传入的参数决定创建并返回哪种产品类的实例。简单来说，就是把对象的创建逻辑封装在一个工厂类中。

实现步骤

1. 定义产品基类：创建一个抽象的产品基类，所有具体产品类都要继承这个基类。
2. 创建具体产品类：实现产品基类的接口，创建具体的产品类。
3. 创建工厂类：在工厂类中定义一个创建产品的方法，根据传入的参数决定创建哪种具体产品。

示例代码

#include
#include

// 定义水果抽象基类，包含纯虚函数 name
class Fruit{
    public:
        // 纯虚函数，用于输出水果名称，派生类需实现
        virtual void name()=0;
};

// 苹果类，继承自 Fruit 类
class Apple:public Fruit{
    public:
        // 重写基类的 name 函数，输出苹果名称
        void name() override{
            std::cout<<"Apple"<<std::endl;
        }
};

// 香蕉类，继承自 Fruit 类
class Banana:public Fruit{
    public:
        // 重写基类的 name 函数，输出香蕉名称
        void name() override{
            std::cout<<"Banana"<<std::endl;
        }
};

// 工厂类，用于创建不同类型的水果对象
class Factory{
    public:
        // 静态方法，根据传入的水果名称创建对应的水果对象
        static std::unique_ptr<Fruit> createFruit(std::string fruit_name){
            if(fruit_name=="apple"){
                // 创建苹果对象并返回其 unique_ptr
                return std::unique_ptr<Fruit>(new Apple());
            }
            else if(fruit_name=="banana"){
                // 创建香蕉对象并返回其 unique_ptr
                return std::unique_ptr<Fruit>(new Banana());
            }
            else{
                // 若名称不匹配，返回空指针
                return nullptr;
            }
        }
};

int main()
{
    // 使用工厂类创建苹果对象
    std::unique_ptr<Fruit> fruit = Factory::createFruit("apple");
    // 调用苹果对象的 name 函数输出名称
    fruit->name();  
    // 使用工厂类创建香蕉对象
    fruit = Factory::createFruit("banana");
    // 调用香蕉对象的 name 函数输出名称
    fruit->name();
    // 再次使用工厂类创建苹果对象
    fruit = Factory::createFruit("apple");

    return 0;
}

优缺点

• 优点：实现简单，将对象的创建和使用分离，提高了代码的可维护性。
• 缺点：工厂类职责过重，违反了开闭原则（对扩展开放，对修改关闭）。如果需要新增产品，就需要修改工厂类的代码。

二、工厂方法模式

概念

工厂方法模式是在简单工厂模式的基础上进行了改进，它将创建对象的具体逻辑延迟到子类中实现。定义一个创建对象的抽象方法，让子类决定实例化哪个具体产品类。

实现步骤

1. 定义产品基类：同简单工厂模式。
2. 创建具体产品类：同简单工厂模式。
3. 定义抽象工厂类：定义一个抽象的工厂类，其中包含一个抽象的创建产品的方法。
4. 创建具体工厂类：继承抽象工厂类，实现创建产品的方法，决定创建哪种具体产品。

示例代码

#include
#include

// 定义抽象基类 Fruit，包含纯虚函数 name
// 任何继承自该类的具体水果类都必须实现 name 函数
class Fruit {
public:
    // 纯虚函数，用于输出水果名称
    virtual void name() = 0;
};

// 定义 Apple 类，继承自 Fruit 类
class Apple : public Fruit {
public:
    // 重写基类的纯虚函数 name，输出苹果名称
    void name() override {
        std::cout << "Apple" << std::endl;
    }
};

// 定义 Banana 类，继承自 Fruit 类
class Banana : public Fruit {
public:
    // 重写基类的纯虚函数 name，输出香蕉名称
    void name() override {
        std::cout << "Banana" << std::endl;
    }
};

// 定义抽象工厂类 Factory，包含纯虚函数 create
// 具体的工厂类需要实现该函数来创建水果对象
class Factory {
public:
    // 纯虚函数，用于创建水果对象
    virtual std::shared_ptr<Fruit> create() = 0;
};

// 定义 AppleFactory 类，继承自 Factory 类
class AppleFactory : public Factory {
public:
    // 重写基类的纯虚函数 create，创建苹果对象
    std::shared_ptr<Fruit> create() override {
        return std::make_shared<Apple>();
    }
};

// 定义 BananaFactory 类，继承自 Factory 类
class BananaFactory : public Factory {
public:
    // 重写基类的纯虚函数 create，创建香蕉对象
    std::shared_ptr<Fruit> create() override {
        return std::make_shared<Banana>();
    }
};

int main() {
    // 创建一个指向 AppleFactory 的智能指针
    std::shared_ptr<Factory> fruit_factory(new AppleFactory());
    // 调用工厂的 create 方法创建苹果对象
    std::shared_ptr<Fruit> fruit = fruit_factory->create();
    // 调用水果对象的 name 方法输出名称
    fruit->name();

    // 重置工厂指针，指向 BananaFactory
    fruit_factory.reset(new BananaFactory());
    // 调用新工厂的 create 方法创建香蕉对象
    fruit = fruit_factory->create();
    // 调用水果对象的 name 方法输出名称
    fruit->name();

    return 0;
}

优缺点

• 优点：符合开闭原则，当需要新增产品时，只需要新增具体产品类和对应的具体工厂类，不需要修改现有代码。
• 缺点：类的数量会增多，增加了系统的复杂度。

三、抽象工厂模式

概念

抽象工厂模式：工厂方法模式通过引入工厂等级结构，解决了简单工厂模式中工厂类职责太重的问题。但由于工厂方法模式中的每个工厂只生产一类产品，可能会导致系统中存在大量的工厂类，势必会增加系统的开销。此时，我们可以考虑将一些相关的产品组成一个产品族（位于不同产品等级结构中功能相关联的产品组成的家族），由同一个工厂来统一生产，这就是抽象工厂模式的基本思想。

实现步骤

1. 定义产品族的抽象基类：为每个产品族定义一个抽象基类。
2. 创建具体产品类：实现每个产品族的具体产品类。
3. 定义抽象工厂类：定义一个抽象的工厂类，其中包含多个创建不同产品的抽象方法。
4. 创建具体工厂类：继承抽象工厂类，实现创建不同产品的方法，决定创建哪些具体产品。

示例代码

#include
#include

// 水果抽象基类，定义了输出水果名称的纯虚函数
class Fruit {
public:
    virtual void name() = 0;
};

// 苹果类，继承自 Fruit 类，实现了输出苹果名称的方法
class Apple : public Fruit {
public:
    void name() override {
        std::cout << "Apple" << std::endl;
    }
};

// 香蕉类，继承自 Fruit 类，实现了输出香蕉名称的方法
class Banana : public Fruit {
public:
    void name() override {
        std::cout << "Banana" << std::endl;
    }
};

// 动物抽象基类，定义了输出动物名称的纯虚函数
class Animal {
public:
    virtual void name() = 0;
};

// 羊类，继承自 Animal 类，实现输出名称方法
class Lamb : public Animal {
public:
    void name() override {
        std::cout << "Lamb" << std::endl;
    }
};

// 狗类，继承自 Animal 类，实现了输出狗名称的方法
class Dog : public Animal {
public:
    void name() override {
        std::cout << "Dog" << std::endl;
    }
};

// 抽象工厂类，定义了获取水果和动物对象的纯虚函数
class Factory {
public:
    virtual std::shared_ptr<Fruit> getFruit(const std::string& name) = 0;
    virtual std::shared_ptr<Animal> getAnimal(const std::string& name) = 0;
};

// 水果工厂类，继承自 Factory 类，实现了获取水果对象的方法，获取动物对象返回空指针
class FruitFactory : public Factory {
public:
    virtual std::shared_ptr<Fruit> getFruit(const std::string& name);
    virtual std::shared_ptr<Animal> getAnimal(const std::string& name);
};

// 动物工厂类，继承自 Factory 类，实现了获取动物对象的方法，获取水果对象返回空指针
class AnimalFactory : public Factory {
public:
    virtual std::shared_ptr<Fruit> getFruit(const std::string& name);
    virtual std::shared_ptr<Animal> getAnimal(const std::string& name);
};

// 工厂管理类，提供静态方法根据名称创建对应的工厂对象
class FactoryManager {
public:
    static std::shared_ptr<Factory> creaete(const std::string& name);
};

int main() {
    // 通过工厂管理类创建水果工厂对象
    std::shared_ptr<Factory> fruit_factory = FactoryManager::creaete("fruit");
    // 从水果工厂获取苹果对象并输出名称
    std::shared_ptr<Fruit> fruit = fruit_factory->getFruit("apple");
    fruit->name();
    // 从水果工厂获取香蕉对象并输出名称
    fruit = fruit_factory->getFruit("banana");
    fruit->name();

    return 0;
}

优缺点

• 优点：将一系列相关的产品对象的创建封装在一起，保证了产品之间的一致性，同时也符合开闭原则。
• 缺点：实现复杂，当产品族需要增加新的产品时，需要修改抽象工厂类和所有具体工厂类的代码。