关于自注册工厂模式的一点思考

上一篇我们提到自注册工厂模式：跳转
是借助一个SharpRegister模板类，在类的构造函数中，创建模板对象，并将其注册到工厂类中，来实现自定义sharp的注册；
为了简化定义 SharpRegister类对象的代码，我们将注册的过程简化为了一个宏定义:REGISTER_SHARP

本篇我们模仿duilib框架中的自注册过程，并将其与我们上篇的自注册进行对比，总结各自的优劣势。
duilib库地址
话不多说，show code：

//------------------------------------------------------------------
class Sharp;
class SharpFactory
{
public:
    static SharpFactory* getInstance()
    {
        static SharpFactory ins;
        return &ins;
    }

    void registerSharp(QString name, Sharp* ins)
    {
        if (!m_sharpMap.contains(name))
        {
            m_sharpMap.insert(name, ins);
        }
    }

    Sharp* getSharp(QString name)
    {
        return m_sharpMap.value(name, nullptr);
    }

private:
    QHash<QString, Sharp*> m_sharpMap;
};

//------------------------------------------------------------------
#define DECLARE_SHARP(class_name) \
public:\
    static Sharp* createObj();	\		//每个类, 只有一个创建类对象的静态函数
    static QString getClassName();		//每个类, 只有一个获取类名的静态函数

//------------------------------------------------------------------
#define IMPLEMENT_SHARP(class_name) \
    Sharp* class_name::createObj() \
    { \
        return static_cast<Sharp*>(new class_name()); \
    } \
   	QString class_name::getClassName() \
    { \
        return #class_name; \
    }

//------------------------------------------------------------------
#define REGISTE_SHARP(class_name)   \
    std::function<Sharp* ()> createFunc = class_name::createObj;    \		//创建对象的函数
    SharpFactory::getInstance()->registerSharp(#class_name, createFunc());

//------------------------------------------------------------------
class Sharp
{
public:
    virtual ~Sharp()
    {
    }

    virtual void paint() = 0;
};

//------------------------------------------------------------------
//圆形
class Circle : public Sharp
{
    DECLARE_SHARP(Circle);		//声明静态创建函数
public:
    virtual void paint() override
    {
        qDebug() << "paint Circle";
    }
};
IMPLEMENT_SHARP(Circle);	//实现静态函数

//------------------------------------------------------------------
//矩形
class Rectangle : public Sharp
{
	DECLARE_SHARP(Rectangle)
public:
    virtual void paint() override
    {
        qDebug() << "paint Rectangle";
    }
};
IMPLEMENT_SHARP(Rectangle)

可以看到，这里是每个继承自Sharp的类，都需要一个静态函数，用来创建当前类的对象，使用时候，要用REGISTE_SHARP(Circle);宏定义，将类名字符串与创建该类对象的静态函数(实例化器)注册到工厂中，然后可以通过Sharp* ptr = SharpFactory::getInstance()->getSharp("class name"); 获取到注册到该类的实例化器；然后调用该实例化器函数，就可以创建一个该类对象

分析这种方式与使用模板类的方式的区别，发现这种方式，每多一个子类，就需要在子类中使用 DECLARE_SHARP与IMPLEMENT_SHARP两个宏定义，为其增加静态的创建和获取类名函数，这样其实也变相增加了使用者的负担；优点就是抛弃了SharpRegister模板类，但是其实之前的注册方式，也可以抛弃掉模板类，直接在宏定义中完成创建和注册，例如

#define REGISTER_COMMAND(name, T)\
        std::function<T* ()> func = []() -> Sharp* { return new T;};	\
        SharpFactory::getInstance()->registerSharp(type, func);

---

提一嘴，如果想要从工厂中直接拿到具体的子类指针，而不是父类指针，则可以将工厂类的Sharp* getSharp(QString name)修改成模板函数，例如：

    template<class T = Sharp>
    T* getSharp(QString name)
    {
        Sharp* ptr = m_sharpMap.value(name, nullptr);
        if (ptr != nullptr)
        {
            return dynamic_cast<T*>(ptr);
        }
        return nullptr;
    }

有兴趣的也可以看下POCO库动态工厂的实现：POCO DynamicFactory