C++设计模式---工厂模式

C++中工厂模式是一种创建型设计模式,它允许客户端代码通过调用工厂方法来创建对象,而无需直接使用new运算符实例化具体类。这种模式有助于将类的创建与使用相分离,并且在需要添加新的具体类时可以减少对客户端代码的影响。

工厂模式通常有两种实现方式:简单工厂模式和抽象工厂模式。简单工厂模式是最基本的工厂模式,它通过一个静态方法来创建具体的对象。而抽象工厂模式则通过一个抽象工厂类来定义一组创建相关对象的方法,每个具体工厂类实现这些方法来创建特定的对象。

1、简单工厂模式

简单工厂模式是最基本的工厂模式,它通过一个静态方法来创建具体的对象。

cpp 复制代码
#include <iostream>  
#include <string>  
  
// 定义产品接口  【抽象类】
class Product {  
public:  
    virtual ~Product() {}  
    virtual void use() const = 0;  // 纯虚函数必须被子类重写
};  
  
// 定义具体产品类  
class ProductA : public Product {  
public:  
    void use() const override {  
        std::cout << "Using ProductA" << std::endl;  
    }  
};  
  
class ProductB : public Product {  
public:  
    void use() const override {  
        std::cout << "Using ProductB" << std::endl;  
    }  
};  
  
// 定义简单工厂类  
class SimpleFactory {  
public:  
    static Product* createProduct(const std::string& type) {  
        if (type == "A") {  
            return new ProductA();  
        } else if (type == "B") {  
            return new ProductB();  
        } else {  
            return nullptr;  
        }  
    }  
};  
  
// 客户端代码  
int main() {  
    Product* productA = SimpleFactory::createProduct("A");  
    if (productA) {  
        productA->use();  
        delete productA; // 释放内存  
    }  
  
    Product* productB = SimpleFactory::createProduct("B");  
    if (productB) {  
        productB->use();  
        delete productB; // 释放内存  
    }   
    return 0;  
}

结果:

cpp 复制代码
Using ProductA
Using ProductB

2、抽象工厂模式

抽象工厂模式则通过一个抽象工厂类来定义一组创建相关对象的方法,每个具体工厂类实现这些方法来创建特定的对象。

基本结构:

(1)抽象工厂(AbstractFactory):声明了一组用于创建产品对象的操作接口。

(2)具体工厂(ConcreteFactory):实现了抽象工厂接口,负责创建具体产品类的对象。

(3)抽象产品(AbstractProduct):定义了一组产品的接口。

(4)具体产品(ConcreteProduct):实现了抽象产品接口,是具体可使用的产品。

示例:有两个产品族(CarBike),每个产品族都有两个具体产品(SportsCarSedanMountainBikeRoadBike)。

cpp 复制代码
#include <iostream>  
#include <string>  

// 抽象产品  
class Car {  
public:  
    virtual ~Car() {}  
    virtual void show() = 0;  
};  
  
class Bike {  
public:  
    virtual ~Bike() {}  
    virtual void show() = 0;  
};  
  
// 具体产品  
class SportsCar : public Car {  
public:  
    void show() override { std::cout << "SportsCar" << std::endl; }  
};  
  
class Sedan : public Car {  
public:  
    void show() override { std::cout << "Sedan" << std::endl; }  
};  
  
class MountainBike : public Bike {  
public:  
    void show() override { std::cout << "MountainBike" << std::endl; }  
};  
  
class RoadBike : public Bike {  
public:  
    void show() override { std::cout << "RoadBike" << std::endl; }  
};  
  
// 抽象工厂  
class VehicleFactory {  
public:  
    virtual ~VehicleFactory() {}  
    virtual Car* createCar() = 0;      // 纯虚函数,必须被子类重写
    virtual Bike* createBike() = 0;    // 纯虚函数,必须被子类重写
};  
  
// 具体工厂  
class AmericanFactory : public VehicleFactory {  
public:  
    Car* createCar() override { return new SportsCar(); }  
    Bike* createBike() override { return new MountainBike(); }  
};  
  
class EuropeanFactory : public VehicleFactory {  
public:  
    Car* createCar() override { return new Sedan(); }  
    Bike* createBike() override { return new RoadBike(); }  
};  
  
// 客户端代码  
int main() {  
    VehicleFactory* americanFactory = new AmericanFactory();  
    Car* americanCar = americanFactory->createCar();  
    Bike* americanBike = americanFactory->createBike();  
    americanCar->show();  
    americanBike->show();  
  
    VehicleFactory* europeanFactory = new EuropeanFactory();  
    Car* europeanCar = europeanFactory->createCar();  
    Bike* europeanBike = europeanFactory->createBike();  
    europeanCar->show();  
    europeanBike->show();  
  
    // 记得释放内存  
    delete americanCar;  
    delete americanBike;  
    delete europeanCar;  
    delete europeanBike;  
    delete americanFactory;  
    delete europeanFactory;  
  
    return 0;  
}

结果:

cpp 复制代码
SportsCar
MountainBike
Sedan
RoadBike

3、区别

(1)产品类数量:

简单工厂模式:通常只有一个抽象产品类,可以派生出多个具体产品类。

抽象工厂模式:有多个抽象产品类,每个抽象产品类都可以派生出多个具体产品类。

(2)工厂类功能:

简单工厂模式:具体工厂类只能创建一个具体产品类的实例。

抽象工厂模式:每个具体工厂类可以创建多个具体产品类的实例,即一个工厂可以创建属于同一产品族但不同等级结构的产品。

(3)接口数量:

简单工厂模式:通常只使用一个接口,用于定义产品的公共方法。

抽象工厂模式:可以使用无限个接口,每个接口对应一个抽象产品类,定义不同产品族的公共方法。

(4)创建对象方式:

简单工厂模式:通过传入参数或配置文件来动态决定创建哪个具体产品类的实例。

抽象工厂模式:无需指定产品的具体类,访问类可以通过抽象工厂接口获取同族的不同等级的产品。

(5)使用场景:

简单工厂模式:适用于创建同种产品类型的复杂参数对象,尤其是当对象的创建过程很复杂,需要很多参数且大部分参数固定时。

抽象工厂模式:适用于系统中有多个产品族,每个具体工厂创建同一族但属于不同等级结构的产品的情况。它可以在类的内部对产品族中相关联的多等级产品共同管理。

(6)优缺点:

简单工厂模式:优点:轻量级,代码结构简单清晰,工厂类可以生产不同的产品。缺点:系统扩展困难,一旦添加新产品就不得不修改工厂逻辑,可能造成工厂逻辑过于复杂,违背了"开放-封闭"原则。

抽象工厂模式:优点:可以在类的内部对产品族中相关联的多等级产品共同管理,而不必专门引入多个新的类来进行管理。缺点:需要增加额外的抽象类和接口,增加了系统的复杂性。

相关推荐
Ajiang28247353041 小时前
对于C++中stack和queue的认识以及priority_queue的模拟实现
开发语言·c++
幽兰的天空1 小时前
Python 中的模式匹配:深入了解 match 语句
开发语言·python
哪 吒4 小时前
最简单的设计模式,抽象工厂模式,是否属于过度设计?
设计模式·抽象工厂模式
Theodore_10224 小时前
4 设计模式原则之接口隔离原则
java·开发语言·设计模式·java-ee·接口隔离原则·javaee
‘’林花谢了春红‘’6 小时前
C++ list (链表)容器
c++·链表·list
----云烟----6 小时前
QT中QString类的各种使用
开发语言·qt
lsx2024066 小时前
SQL SELECT 语句:基础与进阶应用
开发语言
开心工作室_kaic7 小时前
ssm161基于web的资源共享平台的共享与开发+jsp(论文+源码)_kaic
java·开发语言·前端
向宇it7 小时前
【unity小技巧】unity 什么是反射?反射的作用?反射的使用场景?反射的缺点?常用的反射操作?反射常见示例
开发语言·游戏·unity·c#·游戏引擎
武子康7 小时前
Java-06 深入浅出 MyBatis - 一对一模型 SqlMapConfig 与 Mapper 详细讲解测试
java·开发语言·数据仓库·sql·mybatis·springboot·springcloud