文章目录
- C++ 工厂模式
- 引言
- 一、简单工厂模式
- 概念
- 实现步骤
- 示例代码
- 优缺点
- 二、工厂方法模式
- 概念
- 实现步骤
- 示例代码
- 优缺点
- 三、抽象工厂模式
- 概念
- 实现步骤
- 示例代码
- 优缺点
C++ 工厂模式
引言
在 C++ 编程中，对象的创建是一个常见且基础的操作。然而，当项目规模逐渐增大，对象的创建逻辑变得复杂时，直接在代码中使用 new 关键字创建对象会带来诸多问题，比如代码的可维护性变差、难以扩展等。工厂模式应运而生，它为对象的创建提供了一种更加灵活、可扩展的解决方案。本文将详细介绍 C++ 中的工厂模式，包括简单工厂模式、工厂方法模式和抽象工厂模式，并通过具体的例子帮助大家理解。
一、简单工厂模式
概念
简单工厂模式是工厂模式的基础版本，它定义了一个工厂类，该类可以根据传入的参数决定创建并返回哪种产品类的实例。简单来说，就是把对象的创建逻辑封装在一个工厂类中。
实现步骤
- 定义产品基类：创建一个抽象的产品基类，所有具体产品类都要继承这个基类。
- 创建具体产品类：实现产品基类的接口，创建具体的产品类。
- 创建工厂类：在工厂类中定义一个创建产品的方法，根据传入的参数决定创建哪种具体产品。
示例代码
#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_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;
}
优缺点
- 优点：实现简单，将对象的创建和使用分离，提高了代码的可维护性。
- 缺点：工厂类职责过重，违反了开闭原则（对扩展开放，对修改关闭）。如果需要新增产品，就需要修改工厂类的代码。
二、工厂方法模式
概念
工厂方法模式是在简单工厂模式的基础上进行了改进，它将创建对象的具体逻辑延迟到子类中实现。定义一个创建对象的抽象方法，让子类决定实例化哪个具体产品类。
实现步骤
- 定义产品基类：同简单工厂模式。
- 创建具体产品类：同简单工厂模式。
- 定义抽象工厂类：定义一个抽象的工厂类，其中包含一个抽象的创建产品的方法。
- 创建具体工厂类：继承抽象工厂类，实现创建产品的方法，决定创建哪种具体产品。
示例代码
#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();
// 重置工厂指针，指向 BananaFactory
fruit_factory.reset(new BananaFactory());
// 调用新工厂的 create 方法创建香蕉对象
fruit = fruit_factory->create();
// 调用水果对象的 name 方法输出名称
fruit->name();
return 0;
}
优缺点
- 优点：符合开闭原则，当需要新增产品时，只需要新增具体产品类和对应的具体工厂类，不需要修改现有代码。
- 缺点：类的数量会增多，增加了系统的复杂度。
三、抽象工厂模式
概念
抽象工厂模式：工厂方法模式通过引入工厂等级结构，解决了简单工厂模式中工厂类职责太重的问题。但由于工厂方法模式中的每个工厂只生产一类产品，可能会导致系统中存在大量的工厂类，势必会增加系统的开销。此时，我们可以考虑将一些相关的产品组成一个产品族（位于不同产品等级结构中功能相关联的产品组成的家族），由同一个工厂来统一生产，这就是抽象工厂模式的基本思想。
实现步骤
- 定义产品族的抽象基类：为每个产品族定义一个抽象基类。
- 创建具体产品类：实现每个产品族的具体产品类。
- 定义抽象工厂类：定义一个抽象的工厂类，其中包含多个创建不同产品的抽象方法。
- 创建具体工厂类：继承抽象工厂类，实现创建不同产品的方法，决定创建哪些具体产品。
示例代码
#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;
}
优缺点
- 优点：将一系列相关的产品对象的创建封装在一起，保证了产品之间的一致性，同时也符合开闭原则。
- 缺点：实现复杂，当产品族需要增加新的产品时，需要修改抽象工厂类和所有具体工厂类的代码。
