自动注册工厂消灭switch-case

之前在代码重构书中有了解过java中的反射机制可以消除switch-case，详情可以参考这篇博客http://blog.csdn.net/wwh578867817/article/details/49309789。那么我们的C++有没有类似干掉switch-case的方法？

1原始的工厂是如何创建派生类对象的

假如我们有个基类为Father，它有好多继承类分别为Son1，Son2，…
那么我们原始工厂(用来创建其子类对象)方法也就是用switch-case来实现
伪代码如下

Message* create(int type)
{switch (type) {case _Son1_:m = new Son1;break;case _Son2_:m = new Son2;break;case _Son3_:m = new Son3;break;case _Son4_:m = new Son4;break;case __Son5:m = new Son5;break;default:break;}
}

如果我们的case语句少点还好，一旦有好多的case语句，我们的代码维护起来就会变得很麻烦，那么我们有什么办法可以像java的反射机制一样干掉常常的switch-case语句呢？

2.自动注册的对象工厂

没错我们可以实现一个有自动注册功能的对象工厂就可以干掉switch-case了

为什么其可以干掉switch-case?

首先我们的自动注册对象工厂会维护一个map集合，该map的key便是我们上述的switch-case里的type，value为一个可调用对象，该可调用对象会调用具体某个Son类的构造函数，然后返回新生成对象的额指针。在每个子类的头文件中，我们就会将该子类的type和对应的可调用对象插入到map中，这样当我们程序中要生成某个具体子类对象时，我们的工厂便会更具type找到map中对应的可调用对象，然后执行可调用对象便可生成该type所对应的类对象了

具体实现如下

我们把父类看做基础消息，命名为Message，继承其的消息分别为Message2…等
父类代码

#pragma onceclass Message
{public:virtual ~Message(){}virtual void foo()//由子类自己实现的接口{}
};

工厂类的代码实现

#pragma once#include <map>
#include <string>
#include <functional>
#include <memory>
#include "message.h"class Factory
{public:template<typename T>struct Register //用于将特定构造函数的可调用对象插入map的注册类{Register(const std::string &key){Factory::get().map_.emplace(key,[]{return new T();});//lambda表达式作为可调用对象       }template<typename... Args>//构造函数为有参数时Register(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](); //注意lambda在这里执行}//用智能指针来管理裸指针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 *(void)>> map_;   //保存type和可调用对象的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> REGISTER_MESSAGE_VNAME(T)(key,##__VA_ARGS__)

类Message1的代码

#pragma once#include "message.h"
#include "factory.h"
#include <iostream>class Message1 : public Message
{public:Message1(){std::cout << "Message1" << std::endl;}~Message1(){}void foo()override  //自己实现的接口{std::cout << "Message1" << std::endl;}
};REGISTER_MESSAGE(Message1,"Message1");//通过此将执行Message1构造函数的可调用对象插入到map中

类Message2的代码

#pragma once#include "message.h"
#include "factory.h"
#include <iostream>class Message2 : public Message
{public:Message2(){std::cout << "Message2" << std::endl;}Message2(int a){std::cout<< "Message2" <<std::endl;}~Message2(){}void foo()override{std::cout << "Message2" << std::endl;}
};

测试程序的代码


#include "message1.h"
#include "message2.h"
#include "message.h"int main(int argc,char **argv)
{Message *p = Factory::produce("Message1");Message *p1 = Factory::produce("Message2");p->foo();p1->foo();delete p;delete p1;return 0;
}

执行结果为

这样我们就可以用自动注册工厂神奇的消灭掉switch-case了
详细代码请到https://github.com/Miaoshuai/factory