工厂模式实现（c++）

工厂模式是一种创建型设计模式，用于封装对象的创建逻辑。它提供了一个接口来创建对象，但将具体的对象创建委托给子类或工厂方法。工厂模式可以分为两种主要类型：简单工厂模式和工厂方法模式。

• 简单工厂模式：通过一个工厂类来创建对象，根据传入的参数决定创建哪种类型的对象。适用于对象创建逻辑比较简单且不需要扩展的情况。
• 工厂方法模式：定义了一个创建对象的接口，但将具体的对象创建委托给子类。每个子类可以提供不同的实现来创建不同的对象。适用于对象创建逻辑较为复杂且需要扩展的情况。

简单来说，简单工厂模式是有一个工厂类，传入衣服，鞋子参数，分别创建衣服、鞋子对象，

工厂方法模式是一个抽象工厂类，分别创建adidas，nike工厂，然后不同工厂生产各自的鞋子。

1. 简单工厂模式（Simple Factory Pattern）

简单工厂模式通过一个工厂类来创建对象，根据传入的参数决定创建哪种类型的对象。这种模式适用于对象创建逻辑比较简单且不需要扩展的情况。

#include <iostream>

// 产品接口
class Product {
public:
    virtual void use() = 0;
    virtual ~Product() {}
};

// 具体产品A
class ConcreteProductA : public Product {
public:
    void use() override {
        std::cout << "Using ConcreteProductA" << std::endl;
    }
};

// 具体产品B
class ConcreteProductB : public Product {
public:
    void use() override {
        std::cout << "Using ConcreteProductB" << std::endl;
    }
};

// 工厂类
class SimpleFactory {
public:
    static Product* createProduct(const std::string& type) {
        if (type == "A") {
            return new ConcreteProductA();
        } else if (type == "B") {
            return new ConcreteProductB();
        } else {
            return nullptr;
        }
    }
};

int main() {
    Product* productA = SimpleFactory::createProduct("A");
    productA->use();

    Product* productB = SimpleFactory::createProduct("B");
    productB->use();

    delete productA;
    delete productB;

    return 0;
}

2. 工厂方法模式（Factory Method Pattern）

工厂方法模式是一种更灵活的工厂模式，它定义了一个创建对象的接口，但将具体的对象创建委托给子类。每个子类可以提供不同的实现来创建不同的对象。这种模式适用于对象创建逻辑较为复杂且需要扩展的情况。

#include <iostream>

// 产品接口
class Product {
public:
    virtual void use() = 0;
    virtual ~Product() {}
};

// 具体产品A
class ConcreteProductA : public Product {
public:
    void use() override {
        std::cout << "Using ConcreteProductA" << std::endl;
    }
};

// 具体产品B
class ConcreteProductB : public Product {
public:
    void use() override {
        std::cout << "Using ConcreteProductB" << std::endl;
    }
};

// 工厂接口
class Factory {
public:
    virtual Product* createProduct() = 0;
    virtual ~Factory() {}
};

// 具体工厂A
class ConcreteFactoryA : public Factory {
public:
    Product* createProduct() override {
        return new ConcreteProductA();
    }
};

// 具体工厂B
class ConcreteFactoryB : public Factory {
public:
    Product* createProduct() override {
        return new ConcreteProductB();
    }
};

int main() {
    Factory* factoryA = new ConcreteFactoryA();
    Product* productA = factoryA->createProduct();
    productA->use();

    Factory* factoryB = new ConcreteFactoryB();
    Product* productB = factoryB->createProduct();
    productB->use();

    delete productA;
    delete factoryA;
    delete productB;
    delete factoryB;

    return 0;
}

详细解释

1. 简单工厂模式

• 产品接口 Product：

  class Product {
  public:
      virtual void use() = 0;
      virtual ~Product() {}
  };

  • 定义了一个抽象的产品接口，所有具体产品类都必须实现 use 方法。

• 具体产品 ConcreteProductA 和 ConcreteProductB：

  class ConcreteProductA : public Product {
  public:
      void use() override {
          std::cout << "Using ConcreteProductA" << std::endl;
      }
  };
  
  class ConcreteProductB : public Product {
  public:
      void use() override {
          std::cout << "Using ConcreteProductB" << std::endl;
      }
  };

  • 具体产品类实现了 Product 接口中的 use 方法。

• 工厂类 SimpleFactory：

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

  • 工厂类提供了一个静态方法 createProduct，根据传入的参数 type 创建并返回相应的具体产品对象。

• 主函数 main：

  int main() {
      Product* productA = SimpleFactory::createProduct("A");
      productA->use();
  
      Product* productB = SimpleFactory::createProduct("B");
      productB->use();
  
      delete productA;
      delete productB;
  
      return 0;
  }

  • 创建两个具体产品对象 productA 和 productB，并调用它们的 use 方法。

2. 工厂方法模式

• 产品接口 Product：

  class Product {
  public:
      virtual void use() = 0;
      virtual ~Product() {}
  };

  • 定义了一个抽象的产品接口，所有具体产品类都必须实现 use 方法。

• 具体产品 ConcreteProductA 和 ConcreteProductB：

  class ConcreteProductA : public Product {
  public:
      void use() override {
          std::cout << "Using ConcreteProductA" << std::endl;
      }
  };
  
  class ConcreteProductB : public Product {
  public:
      void use() override {
          std::cout << "Using ConcreteProductB" << std::endl;
      }
  };

  • 具体产品类实现了 Product 接口中的 use 方法。

• 工厂接口 Factory：

  class Factory {
  public:
      virtual Product* createProduct() = 0;
      virtual ~Factory() {}
  };

  • 定义了一个抽象的工厂接口，所有具体工厂类都必须实现 createProduct 方法。

• 具体工厂 ConcreteFactoryA 和 ConcreteFactoryB：

  class ConcreteFactoryA : public Factory {
  public:
      Product* createProduct() override {
          return new ConcreteProductA();
      }
  };
  
  class ConcreteFactoryB : public Factory {
  public:
      Product* createProduct() override {
          return new ConcreteProductB();
      }
  };

  • 具体工厂类实现了 Factory 接口中的 createProduct 方法，分别创建 ConcreteProductA 和 ConcreteProductB 对象。

• 主函数 main：

  int main() {
      Factory* factoryA = new ConcreteFactoryA();
      Product* productA = factoryA->createProduct();
      productA->use();
  
      Factory* factoryB = new ConcreteFactoryB();
      Product* productB = factoryB->createProduct();
      productB->use();
  
      delete productA;
      delete factoryA;
      delete productB;
      delete factoryB;
  
      return 0;
  }

  • 创建两个具体工厂对象 factoryA 和 factoryB，并通过它们创建具体产品对象 productA 和 productB，然后调用它们的 use 方法。