工厂模式学习

0.引言

承接上一篇我的需求。

1.简单工厂模式

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

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

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

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

当然 if else 可以使用 switch 替代：

enum PRODUCT_TYPE
{
    A,
    B,
    C
};


class Factory
{
public:
    static Product* createProduct(PRODUCT_TYPE type)
    {
        switch (type)
        {
        case A:
            return new ConcreteProductA();
            break;
        case B:
            return new ConcreteProductB();
            break;
        default:
            return NULL;
            break;
        }
        return nullptr;
    }
};

在这个示例中，我们定义了一个抽象类 Product，表示产品的基类，它定义了一个抽象函数 use，用于表示产品的使用方法。然后我们定义了两个具体产品类 ConcreteProductA 和 ConcreteProductB，继承自 Product，实现了 use 函数，表示两种不同的产品。

接下来，我们定义了一个工厂类 Factory，它提供了一个静态成员函数 createProduct，用于根据产品名称返回相应的产品对象。

在使用该工厂类时，我们可以这样来创建产品对象：

Product* productA = Factory::createProduct("A");
Product* productB = Factory::createProduct("B");

2.反射工厂

反射工厂模式是一种使用反射机制来实现动态创建对象的设计模式。下面是一个 C++ 实现的反射工厂模式示例，它演示了如何通过反射机制动态创建对象：

#include <iostream>
#include <map>
#include <string>

// 基类
class Base {
 public:
  virtual ~Base() {}
  virtual void print() = 0;
};

// 子类A
class A : public Base {
 public:
  void print() override { std::cout << "class A" << std::endl; }
};

// 子类B
class B : public Base {
 public:
  void print() override { std::cout << "class B" << std::endl; }
};

// 工厂类
class Factory {
 public:
  typedef Base* (*CreateFunc)();

  static Base* create(const std::string& className) {
    if (m_map.find(className) == m_map.end()) {
      return nullptr;
    }

    CreateFunc func = m_map[className];
    return func();
  }

  static void registerClass(const std::string& className, CreateFunc func) {
    m_map[className] = func;
  }

 private:
  static std::map<std::string, CreateFunc> m_map;
};

std::map<std::string, Factory::CreateFunc> Factory::m_map;

#define REGISTER_CLASS(className)                              \
  static Base* create##className() { return new className(); } \
  static bool b_##className = []() {                           \
    Factory::registerClass(#className, create##className);     \
    return true;                                               \
  }();

// 注册子类
REGISTER_CLASS(A);
REGISTER_CLASS(B);

int main() {
  // 通过工厂类动态创建对象
  Base* a = Factory::create("A");
  if (a != nullptr) {
    a->print();
    delete a;
  }

  Base* b = Factory::create("B");
  if (b != nullptr) {
    b->print();
    delete b;
  }

  return 0;
}

在这个示例中，我们定义了一个基类 Base，并定义了两个子类 A 和 B，它们都实现了 print 方法。然后我们定义了一个工厂类 Factory，它提供了两个方法 create 和 registerClass，用于动态创建对象和注册子类。

为了方便使用，我们定义了一个宏 REGISTER_CLASS，它可以为子类自动生成创建函数和注册代码。使用 REGISTER_CLASS 宏为子类 A 和 B 自动生成创建函数和注册代码，然后通过工厂类的 create 方法来动态创建子类的对象。

在这个示例中，我们使用了 C++ 中的反射机制，即在运行时通过类名来查找并调用相应的创建函数，从而实现了动态创建对象的功能。反射工厂模式的优点是可以动态地添加新的子类，并且可以在运行时动态地创建不同的子类对象。