设计模式——工厂模式

简单工厂模式示例

定义产品抽象类

首先，定义一个抽象产品类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产品的抽象方法。具体工厂类实现了这些方法，用于创建特定组合的产品。这种模式适用于创建产品族，当需要创建不同的产品族组合时，只需要使用相应的具体工厂类即可。它使得代码更加灵活，能够更好地应对产品族的变化，并且保证了产品族内产品的一致性。