设计模式——工厂模式

简单工厂模式示例

定义产品抽象类

首先,定义一个抽象产品类Product,它是所有具体产品类的基类,包含一个纯虚函数operation,用于定义产品的操作行为。

cpp 复制代码
 class Product {
 public:
     virtual void operation() = 0;
     virtual ~Product() {}
 };

定义具体产品类

接着,创建两个具体产品类ConcreteProductA和ConcreteProductB,它们继承自Product类,并实现了operation函数。

cpp 复制代码
 class ConcreteProductA : public Product {
 public:
     void operation() override {
         std::cout << "ConcreteProductA operation" << std::endl;
     }
 };
 class ConcreteProductB : public Product {
 public:
     void operation() override {
         std::cout << "ConcreteProductB operation" << std::endl;
     }
 };

定义工厂类

然后,定义一个简单工厂类SimpleFactory,它有一个createProduct函数,根据传入的参数来创建不同类型的产品。

cpp 复制代码
 class SimpleFactory {
 public:
     Product* createProduct(const std::string& type) {
         if (type == "A") {
             return new ConcreteProductA();
         } else if (type == "B") {
             return new ConcreteProductB();
         }
         return nullptr;
     }
 };

使用工厂类创建产品

最后,在main函数中使用简单工厂来创建产品并调用产品的操作函数。

cpp 复制代码
 int main() {
     SimpleFactory factory;
     Product* productA = factory.createProduct("A");
     if (productA) {
         productA->operation();
         delete productA;
     }
     Product* productB = factory.createProduct("B");
     if (productB) {
         productB->operation();
         delete productB;
     }
     return 0;
 }

解释

简单工厂模式将对象的创建和使用分离。在这个例子中,SimpleFactory类负责创建Product的具体子类对象。当需要创建不同类型的产品时,只需要调用工厂类的createProduct函数并传入相应的类型参数,就可以得到所需的产品对象。这样可以避免在客户端代码中直接使用new操作符来创建对象,提高了代码的可维护性和可扩展性。如果要添加新的产品类型,只需要在工厂类的createProduct函数中添加相应的创建逻辑即可。

工厂方法模式示例

定义产品抽象类和具体产品类(与简单工厂模式类似)

产品抽象类Product和具体产品类ConcreteProductA、ConcreteProductB的定义与简单工厂模式相同。

定义抽象工厂类

创建一个抽象工厂类Factory,它包含一个纯虚函数createProduct,用于创建产品对象。

cpp 复制代码
 class Factory {
 public:
     virtual Product* createProduct() = 0;
     virtual ~Factory() {}
 };

定义具体工厂类

为每个具体产品类创建对应的具体工厂类。例如,ConcreteFactoryA用于创建ConcreteProductA,ConcreteFactoryB用于创建ConcreteProductB。

cpp 复制代码
 class ConcreteFactoryA : public Factory {
 public:
     Product* createProduct() override {
         return new ConcreteProductA();
     }
 };
 class ConcreteFactoryB : public Factory {
 public:
     Product* createProduct() override {
         return new ConcreteProductB();
     }
 };

使用工厂类创建产品

在main函数中,通过具体工厂类来创建产品并调用产品的操作函数。

cpp 复制代码
 int main() {
     ConcreteFactoryA factoryA;
     Product* productA = factoryA.createProduct();
     if (productA) {
         productA->operation();
         delete productA;
     }
     ConcreteFactoryB factoryB;
     Product* productB = factoryB.createProduct();
     if (productB) {
         productB->operation();
         delete productB;
     }
     return 0;
 }

解释

工厂方法模式在简单工厂模式的基础上,将工厂类也进行了抽象。每个具体产品类都有对应的具体工厂类。这种模式符合开闭原则,即当需要添加新的产品类型时,只需要创建新的具体产品类和对应的具体工厂类,而不需要修改现有的代码。这样可以更好地应对产品类型的变化,使得代码的扩展性更强。

抽象工厂模式示例

定义产品族抽象类和具体产品类

假设我们有两个产品族,一个是Shape产品族,包含Circle和Rectangle;另一个是Color产品族,包含Red和Blue。

首先定义Shape产品族的抽象类和具体类:

cpp 复制代码
 class Shape {
 public:
     virtual void draw() = 0;
     virtual ~Shape() {}
 };
 class Circle : public Shape {
 public:
     void draw() override {
         std::cout << "Drawing a circle" << std::endl;
     }
 };
 class Rectangle : public Shape {
 public:
     void draw() override {
         std::cout << "Drawing a rectangle" << std::endl;
     }
 };

然后定义Color产品族的抽象类和具体类:

cpp 复制代码
 class Color {
 public:
     virtual void fill() = 0;
     virtual ~Color() {}
 };
 class Red : public Color {
 public:
     void fill() override {
         std::cout << "Filling with red" << std::endl;
     }
 };
 class Blue : public Color {
 public:
     void fill() override {
         std::cout << "Filling with blue" << std::endl;
     }
 };

定义抽象工厂类

创建一个抽象工厂类AbstractFactory,它包含两个纯虚函数createShape和createColor,用于分别创建Shape和Color产品。

cpp 复制代码
 class AbstractFactory {
 public:
     virtual Shape* createShape() = 0;
     virtual Color* createColor() = 0;
     virtual ~AbstractFactory() {}
 };

定义具体工厂类

为每个产品组合创建具体工厂类。例如,ShapeColorFactory1用于创建Circle和Red,ShapeColorFactory2用于创建Rectangle和Blue。

cpp 复制代码
 class ShapeColorFactory1 : public AbstractFactory {
 public:
     Shape* createShape() override {
         return new Circle();
     }
     Color* createColor() override {
         return new Red();
     }
 };
 class ShapeColorFactory2 : public AbstractFactory {
 public:
     Shape* createShape() override {
         return new Rectangle();
     }
     Color* createColor() override {
         return new Blue();
     }
 };

使用抽象工厂类创建产品组合

在main函数中,通过具体工厂类来创建产品组合并调用产品的操作函数。

cpp 复制代码
 int main() {
     ShapeColorFactory1 factory1;
     Shape* shape1 = factory1.createShape();
     Color* color1 = factory1.createColor();
     if (shape1 && color1) {
         shape1->draw();
         color1->fill();
         delete shape1;
         delete color1;
     }
     ShapeColorFactory2 factory2;
     Shape* shape2 = factory2.createShape();
     Color* color2 = factory2.createColor();
     if (shape2 && color2) {
         shape2->draw();
         color2->fill();
         delete shape2;
         delete color2;
     }
     return 0;
 }

解释

抽象工厂模式提供了一种创建一系列相关或相互依赖对象的接口,而无需指定它们具体的类。在这个例子中,AbstractFactory类定义了创建Shape和Color产品的抽象方法。具体工厂类实现了这些方法,用于创建特定组合的产品。这种模式适用于创建产品族,当需要创建不同的产品族组合时,只需要使用相应的具体工厂类即可。它使得代码更加灵活,能够更好地应对产品族的变化,并且保证了产品族内产品的一致性。

相关推荐
feilieren12 分钟前
leetcode - 684. 冗余连接
java·开发语言·算法
余~1853816280022 分钟前
矩阵系统源码搭建,OEM贴牌技术
网络·人工智能·线性代数·算法·矩阵
Tianwen_Burning32 分钟前
Halcon相机外参自理解
算法
dawn1912282 小时前
Java 中的正则表达式详解
java·开发语言·算法·正则表达式·1024程序员节
黑不拉几的小白兔2 小时前
PTA L1系列题解(C语言)(L1_097 -- L1_104)
数据结构·算法·1024程序员节
南城花随雪。2 小时前
蚁群算法(Ant Colony Optimization)详细解读
算法
lLinkl3 小时前
Java面试经典 150 题.P27. 移除元素(002)
算法
tangguofeng3 小时前
合并排序算法(C语言版)
算法
ChaoZiLL3 小时前
关于我的数据结构与算法——初阶第二篇(排序)
数据结构·算法
爱编程的古惑仔3 小时前
leetcode刷题笔记——15.三数之和
笔记·算法·leetcode