C++11 实现一个自动注册的工厂

音视频开发进阶

共 3914字,需浏览 8分钟

 ·

2021-10-28 11:46

之前在项目代码里面看到同事写了个自动注册的工厂类,虽然当时我看不懂,但我大受震撼。

今天又重新温习了一下这种写法,分享给大家,可见学好 C++ 是多么的重要

实现动机

工厂方法是最简单地创建派生类对象的方法,也是很常用的,工厂方法内部使用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;
    static std::map<std::stringstd::function> map_; 
};

在C++11中单例的实现非常简单,返回一个一个静态局部变量的引用即可,而且这个方法还是线程安全的,因为C++11中静态局部变量的初始化是线程安全的。

工厂内部有一个map,map的值类型为一个function,是对象的构造器。

对象工厂的辅助类的代码

struct factory
{

    template<typename T>
    struct register_t
    {

        register_t(const std::string& key)
        {
            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和泛型对象的构造器。

这里用到了C++11的一个新特性:内部类可以通过外部类的实例访问外部类的私有成员,所以register_t可以直接访问factory的私有变量map_。

自动注册的代码

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

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

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

REGISTER_MESSAGE(Message1, "message1");

自动注册的关键是通过一个宏来生成静态全局的register_t的实例,因为register_t的实例是用来向工厂注册目标对象的构造器

所以仅仅需要在派生类中调用这个宏就可以实现自动至注册了,而无需修改原有代码。

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

Factory最终的实现

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

struct factory
{

    template<typename T>
    struct register_t
    {

        register_t(const std::string& key)
        {
            factory::get().map_.emplace(key, [] { return new T(); });
        }

        template<typename... Args>
        register_t(const std::string& key, Args... args)
        
{
            factory::get().map_.emplace(key, [&] { return new T(args...); });
        }
    };

    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]();
    }

    static std::unique_ptr produce_unique(const std::string& key)
    
{
        return std::unique_ptr(produce(key));
    }

    static std::shared_ptr produce_shared(const std::string& key)
    
{
        return std::shared_ptr(produce(key));
    }

private:
    factory() {};
    factory(const factory&) = delete;
    factory(factory&&) = delete;

    static factory& get()
    
{
        static factory instance;
        return instance;
    }

    static std::map<std::stringstd::function> map_;
};

std::map<std::stringstd::function> factory::map_;

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

示例:

class Message
{

public:
    virtual ~Message() {}

    virtual void foo()
    
{

    }
};
#include "MessageFactory.hpp"
#include "Message.hpp"

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");

#include "Message1.hpp"

int main()
{
    Message* p = factory::produce("message1");
    p->foo();   //Message1
    
    auto p2 = factory::produce_unique("message1");
    p2->foo();
}

总结:

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

完整代码可以参考:

https://github.com/qicosmos/cosmos/tree/master/self-register-factory

作者:qicosmos

地址:https://www.cnblogs.com/qicosmos/p/5090159.html


技术交流,欢迎加我微信:ezglumes ,拉你入技术交流群。

私信领取相关资料

推荐阅读:

音视频开发工作经验分享 || 视频版

OpenGL ES 学习资源分享

开通专辑 | 细数那些年写过的技术文章专辑

NDK 学习进阶免费视频来了

你想要的音视频开发资料库来了

推荐几个堪称教科书级别的 Android 音视频入门项目

觉得不错,点个在看呗~

浏览 26
点赞
评论
收藏
分享

手机扫一扫分享

分享
举报
评论
图片
表情
推荐
点赞
评论
收藏
分享

手机扫一扫分享

分享
举报