工厂方法模式

定会一个用于创建对象的接口，让子类决定实例化哪一个类。工厂方法使得一个类的实例化延迟到其子类。

简单工厂模式的最大优点在于：工厂类中包含了必要的逻辑判断，根据客户端的选择条件动态实例化相关的类，对于客户端来说，去除了与具体产品的依赖。
但是如果要增加功能，就需要增加 case 分支条件，修改原有的类（不仅对扩展开放了，对修改也开放了），违背开放-封闭原则。

将工厂类抽象出一个接口，只有一个方法——创建抽象产品的工厂方法。所有要生产具体类的工厂就去实现这个接口。

#include <iostream>
#include <memory>
class Product {
public:
  void func1() { std::cout << "func1\n"; }
  void func2() { std::cout << "func2\n"; }
  void func3() { std::cout << "func3\n"; }
};
class ConcreteProduct1 final : public Product {};
class ConcreteProduct2 final : public Product {};
class ProductFactory {
public:
  virtual std::unique_ptr<Product> createProduct() = 0;
};
class ConcreteProduct1Factory final : public ProductFactory {
public:
  std::unique_ptr<Product> createProduct() {
    return std::make_unique<ConcreteProduct1>();
  }
};
class ConcreteProduct2Factory final : public ProductFactory {
public:
  std::unique_ptr<Product> createProduct() {
    return std::make_unique<ConcreteProduct2>();
  }
};
auto main() -> int {
  std::unique_ptr<ProductFactory> pf =
      std::make_unique<ConcreteProduct1Factory>();
  std::unique_ptr<Product> product = pf->createProduct();
  product->func1();
  product->func2();
  product->func3();
  pf = std::make_unique<ConcreteProduct2Factory>();
  product = pf->createProduct();
  product->func1();
  product->func2();
  product->func3();
}

实际上也有缺点：每加一个产品就需要增加一个产品工厂的类，增加了额外的开发量。