C++ 工厂模式

引言

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

一、简单工厂模式

概念

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

实现步骤

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

示例代码

#include<iostream>
#include<memory>// 定义水果抽象基类，包含纯虚函数 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_ptrreturn std::unique_ptr<Fruit>(new Apple());}else if(fruit_name=="banana"){// 创建香蕉对象并返回其 unique_ptrreturn 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<iostream>
#include<memory>// 定义抽象基类 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();// 重置工厂指针，指向 BananaFactoryfruit_factory.reset(new BananaFactory());// 调用新工厂的 create 方法创建香蕉对象fruit = fruit_factory->create();// 调用水果对象的 name 方法输出名称fruit->name();return 0;
}

优缺点

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

三、抽象工厂模式

概念

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

实现步骤

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

示例代码

#include<iostream>
#include<memory>// 水果抽象基类，定义了输出水果名称的纯虚函数
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;
}

优缺点

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