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

转载于:http://geek.csdn.net/news/detail/48963


工厂方法是最简单的创建派生类对象的方法,也是很常用的,工厂方法内部使用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::string, std::function<Message * ()>> map_;
};
在C++11中单例的实现非常简单,返回一个一个静态局部变量的引用即可,而且这个方法还是线程安全的,因为C++11中静态局部变量的初始化是线程安全的。工厂内部有一个map,map的值类型为一个function,是对象的构造器。

对象工厂的辅助类的代码:
struct factory {
template<typename t>
struct reister_t {
reister_t(const std::string & key) {
//emplace 如果新元素的主键是唯一的,将插入该元素
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<T> REGISTER_MESSAGE_VNAME(T)(key, __VA_ARGS__); 
class Message1 : public Message {
//...
};
REGISTER_MESSAGE(Message1, "message1");
自动注册的关键是通过一个宏来生成静态全局的register_t的实例,因为register_t的实例是用来向工厂注册目标对象的构造器。所以仅仅需要在派生类中调用这个宏就可以实现自动至注册了,而无需修改原有代码。
我们还可以添加智能指针接口,无需让用户管理原始指针,甚至让工厂能创建带任意参数的对象。

Factory最终的实现
#include <map>
#include <string>
#include <functional>
#include <memory>
#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<Message> produce_unique(const std::string & key) {
return std::unique_ptr<Message>(produce(key));
}
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;
static factory & get() {
static factory instance;
return instance;
}
static std::map<std::string, std::function<Message *()>> map_;
};


std::map<std::string, std::function<Message *()>> 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 Message {
public:
virtual ~Message() {}
virtual void foo() {}
};
------------------------------
#include "Message.hpp"
#include "MsgFactory.hpp"
class Message1 : public Message {
public:
Message1() {
std::cout << "message1" << std::endl;
}
~Message1() {}
void foo() override {
std::cout << "message1" << std::endl;
}

};
REGISTER_MESSAGE(Message1, "message1");
------------------------------------------
#include "Message1.hpp"
int main() {
Message * p = factory::produce("message1");
p->foo(); //Message1
delete p;
...
auto p2 = factory::produce_unique("message1");
p2->foo();
}


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

完整的代码:https://github.com/qicosmos/cosmos/tree/master/self-register-factory

作者简介: 
祁宇:珠海云创科技研发中心技术总监,资深C++技术专家。 
致力于C++11的应用、研究和推广。珠海云创科技研发中心技术总监,负责公司云基础架构的研发。精通OOP、OOD、设计模式和重构,主要研究方向为架构设计和业务重构,有丰富的开发和研发管理经验。爱好C++,爱好开源,乐于研究和分享技术,开源了多个项目。


评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值