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