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++ 中的反射机制,即在运行时通过类名来查找并调用相应的创建函数,从而实现了动态创建对象的功能。反射工厂模式的优点是可以动态地添加新的子类,并且可以在运行时动态地创建不同的子类对象。