【转载】C++11 实现一个自动注册的工厂

ShaderJoy
306 阅读5分钟

原文地址：C++11 实现一个自动注册的工厂

我对文章格式和一些错别字进行了调整，并标注了重要的部分。以下是文章正文

实现动机

工厂方法是最简单地创建派生类对象的方法，也是很常用的，工厂方法内部使用 switch-case 根据不同的 key 去创建不同的派生类对象，下面是一个伪代码。

Message* create(int type)
{
    switch (type) 
    {
    case MSG_PGSTATS:
        m = new MPGStats;
        break;
    case MSG_PGSTATSACK:
        m = new MPGStatsAck;
        break;
    case CEPH_MSG_STATFS:
        m = new MStatfs;
        break;
    case CEPH_MSG_STATFS_REPLY:
        m = new MStatfsReply;
        break;
    case MSG_GETPOOLSTATS:
        m = new MGetPoolStats;
        break;
    default:
        break;
    }
}

随着时间的流逝，消息种类越来越多，这个 switch-case 会越来越长，我在一个开源项目中看到过一百多个 case 语句，显然这种简单工厂已经不堪负荷，这样的代码对于维护者来说也是一个噩梦。要消除这些长长的 switch-case 语句是一个需要解决的问题，而自动注册的对象工厂则是一个比较优雅的解决方案。

自动注册的对象工厂遵循了开放-封闭原则，新增对象时无需修改原有代码，仅仅需要扩展即可，彻底地消除了 switch-case 语句。

实现方法

自动注册的对象工厂的实现思路如下：

  1. 提供一个单例工厂对象。
  2. 工厂注册对象（保存创建对象的 key 和构造器）。
  3. 利用辅助类，在辅助类对象的构造过程中实现目标对象地注册。
  4. 利用一个宏来生成辅助类对象。
  5. 在派生类文件中调用这个宏实现自动注册。

其中，需要注意的是，对象工厂并不直接保存对象，而是对象的构造器，因为对象工厂不是对象池，是对象的生产者，允许不断地创建实例，另外，这样做还实现了延迟创建。另外一个要注意的地方是借助宏来实现自动注册，本质上是通过宏来定义了很多全局的静态变量，而这些静态变量仅仅是为了实现自动注册，并没有实际的意义。

下面来看看如何用 C++11 来实现这个自动注册的对象工厂。

一个单例的对象工厂代码

struct factory
{
    static factory& get()
    {
        static factory instance; ///< 静态局部变量的初始化是线程安全的
        return instance; ///< 返回一个静态局部变量的引用
    }
private:
    factory() {};
    factory(const factory&) = delete;
    factory(factory&&) = delete;
    /// @note map 中存的是 function 类型
    static std::map<std::string, std::function<Message*()>> map_; 
};

在 C++11 中单例的实现非常简单，返回 一个静态局部变量的引用 即可，而且这个方法还是线程安全的，因为 C++11 中静态局部变量的初始化是线程安全的。工厂内部有一个 map ，map 的值类型为一个 function ，是对象的构造器。

对象工厂的辅助类的代码

struct factory
{
    /// @note 辅助类
    template<typename T>
    struct register_t
    {
        register_t(const std::string& key)
        {
            /// @note 内部类可以通过外部类的实例访问外部类的私有成员
            factory::get().map_.emplace(key, []{ return new T; });
        }
    };
private:
    inline static factory& get()
    {
        static factory instance;
        return instance;
    }
    
    static std::map<std::string, FunPtr> map_;
};

对象工厂的辅助类 register_t 是工厂类的一个内部模版类，非常简单，只有一个构造函数，这个构造函数中调用了 factory 的私有变量 map_ ，并往 map_ 中插入了 key 和泛型对象的构造器【function 对象】。这里用到了 C++11 的一个新特性：内部类可以通过外部类的实例访问外部类的私有成员，所以 register_t 可以直接访问 factory 的私有变量 map_ 。

自动注册的代码

#define REGISTER_MESSAGE_VNAME(T) reg_msg_##T##_
#define REGISTER_MESSAGE(T, key, ...) static factory::register_t<T> REGISTER_MESSAGE_VNAME(T)(key, __VA_ARGS__);

在派生类中调用宏注册自己：

class Message1 : public Message
{
    //……
};

REGISTER_MESSAGE(Message1, "message1");

自动注册的关键是通过一个宏来生成静态全局的 register_t 的实例，因为 register_t 的实例是用来向工厂注册目标对象的构造器【function 对象】。所以仅仅需要在派生类中调用这个宏就可以实现自动注册【将构造器添加到工厂的 map 中】了，而无需修改原有代码。

我们还可以添加智能指针接口，无需让用户管理原始指针，甚至让工厂能创建带任意参数的对象。

Factory 最终的实现

#include <map>
#include <string>
#include <functional>
#include <memory>
#include "Message.hpp"

/// @note 工厂类
struct factory
{
    /// @note 辅助类
    template<typename T>
    struct register_t
    {
        /// @note 为了让可变参模板函数递归终止
        register_t(const std::string& key)
        {
            factory::get().map_.emplace(key, [] { return new T(); });
        }

        /// @note 可变参模板函数
        template<typename... Args>
        register_t(const std::string& key, Args... args)
        {
            factory::get().map_.emplace(key, [&] { return new T(args...); });
        }
    };

    /// @note 调用指定 key 的对象构造器并返回其指针
    static Message* produce(const std::string& key)
    {
        if (map_.find(key) == map_.end())
            throw std::invalid_argument("the message key is not exist!");

        return map_[key]();
    }

    /// @note 同上，但用 std::unique_ptr 封装返回指针
    static std::unique_ptr<Message> produce_unique(const std::string& key)
    {
        return std::unique_ptr<Message>(produce(key));
    }

    /// @note 同上，但用 std::shared_ptr 封装返回指针
    static std::shared_ptr<Message> produce_shared(const std::string& key)
    {
        return std::shared_ptr<Message>(produce(key));
    }

private:
    factory() {};
    factory(const factory&) = delete;
    factory(factory&&) = delete;
    
    /// @note 单例
    static factory& get()
    {
        static factory instance;
        return instance;
    }
    
    /// @note 声明静态成员变量，存储（Message 的派生类的）构造器
    static std::map<std::string, std::function<Message*()>> map_;
};

/// @note 静态成员变量的类外定义
std::map<std::string, std::function<Message*()>> factory::map_;

/// @note 自动注册的宏定义
#define REGISTER_MESSAGE_VNAME(T) reg_msg_##T##_
#define REGISTER_MESSAGE(T, key, ...) static factory::register_t<T> REGISTER_MESSAGE_VNAME(T)(key, ##__VA_ARGS__);

示例

/// @note 基类
class Message
{
public:
    virtual ~Message() {}

    virtual void foo()
    {

    }
};

#include "MessageFactory.hpp"
#include "Message.hpp"

/// @note 派生类
class Message1 : public Message
{
public:

    Message1()
    {
        std::cout << "message1" << std::endl;
    }

    Message1(int a)
    {
        std::cout << "message1" << std::endl;
    }

    ~Message1()
    {
    }

    void foo() override
    {
        std::cout << "message1" << std::endl;
    }
};

//REGISTER_MESSAGE(Message1, "message1", 2);
REGISTER_MESSAGE(Message1, "message1"); ///< 自动注册 Message1 的构造器

#include "Message1.hpp"

int main()
{
    /// @note 构造 Message1 实例（原始指针）
    Message* p = factory::produce("message1");
    p->foo();   //Message1
    
    /// @note 构造 Message1 实例（智能指针）
    auto p2 = factory::produce_unique("message1");
    p2->foo();
}

总结

使用 C++11，仅仅需要几十行代码就可以实现一个自动注册的对象工厂，消除了长长的 swithc-case 语句，还遵循了开闭原则，简洁而优雅。

完整的代码请戳

如果都是 hpp 的消息是没问题的，如果是 h 和 cpp 分开的那种，多个 cpp 包含含静态变量的头文件会引起的链接问题，这就把静态变量干掉，可以参考这个实现

一点梦想：尽自己一份力，让 C++ 的世界变得更美好！

avatar
文章
阅读
粉丝