C++11 模板类自动注册工厂

自动注册工厂CSDN里已经有人解析过了，这里是学习过程中的总结、并详细解析。话不多说，先看代码：

oly_auto_factory.h

 1 #pragma once
 2 #include <functional>
 3 #include <map>
 4 #include <memory>
 5 #include <string>
 6 
 7 namespace oly {
 8 /**
 9  * T 需要传入基类
10  */
11 template <typename T>
12 class auto_factory {
13 public:
14     /**
15      * N 子类，这里会把对应子类添加到Map中
16      */
17     template <typename N>
18     struct register_t {
19         template <typename... Args>
20         register_t(const std::string& key, Args... args)
21         {
22             auto_factory::instance()->_map.emplace(key, [=] { return new N(args...); });
23         }
24     };
25 
26     /**
27      * 普通指针
28      */
29     static auto normal_ptr(const std::string& key) -> T*
30     {
31         return auto_factory::instance()->find(key);
32     }
33 
34     /**
35      * unique_ptr指针
36      */
37     static std::unique_ptr<T> unique_ptr(const std::string& key)
38     {
39         return std::unique_ptr<T>(normal_ptr(key));
40     }
41 
42     /**
43      * shared_ptr指针
44      */
45     static std::shared_ptr<T> shared_ptr(const std::string& key)
46     {
47         return std::shared_ptr<T>(normal_ptr(key));
48     }
49 
50 private:
51     auto_factory(){};
52     auto_factory(const auto_factory&) = delete;
53     auto_factory(auto_factory&&)      = delete;
54     auto_factory& operator=(const auto_factory&) = delete;
55 
56     /**
57      * 单例模式
58      */
59     static auto instance() -> auto_factory<T>*
60     {
61         static auto_factory<T> ins;
62         return &ins;
63     }
64 
65     auto find(const std::string& key) -> T*
66     {
67         if (_map.find(key) == _map.end())
68             throw std::invalid_argument("key is not exist!");
69 
70         return _map[key]();
71     }
72     std::map<std::string, std::function<T*()>> _map;
73 };
74 }  // namespace oly

 

下面我们来看具体应用，基类class B

#include <iostream>
#include "oly_auto_factory.h"

class B {
public:
    virtual void display() = 0;
};
/**
 * 注册基类
 */
#define AF_OBJECT oly::auto_factory<B>
/**
 * 注册子类，这里没有对继承关系进行判断，需要保证继承关系
 */
#define REGISTER_AF_OBJECT_CLASS(CLASS, ...) AF_OBJECT::register_t<CLASS> __##CLASS(#CLASS, ##__VA_ARGS__)

　　

子类 class  FirstB; class SecondB ;class ThirdB 

 1 class FirstB : public B {
 2 public:
 3     void display() override
 4     {
 5         std::cout << __func__ << " FirstB\n";
 6     }
 7 };
 8 REGISTER_AF_OBJECT_CLASS(FirstB);
 9 
10 class SecondB : public B {
11 public:
12     SecondB(const std::string name = "")
13     {
14         nameString = name;
15     }
16 
17     void display() override
18     {
19         std::cout << __func__ << " SecondB\n";
20         std::cout << nameString << "\n";
21     }
22 
23 private:
24     std::string nameString;
25 };
26 REGISTER_AF_OBJECT_CLASS(SecondB, "Welcome");  //带参构造函数
27 
28 class ThirdB : public B { 
29 public:
30     ThirdB(int age, const std::string name = "")
31     {
32         nameString = name;
33         ageInt     = age;
34     }
35     void display() override
36     {
37         std::cout << __func__ << " ThirdB\n";
38         std::cout << nameString << ":" << ageInt << "\n";
39     }
40 
41 private:
42     std::string nameString;
43     int         ageInt;
44 };
45 REGISTER_AF_OBJECT_CLASS(ThirdB, 20, "Tom"); //带参构造函数

 

类下面的 REGISTER_AF_OBJECT_CLASS(FirstB); 是实现自动注册的关键。当我看到这个REGISTER_AF_OBJECT_CLASS();时一脸懵逼，函数怎么可以在函数体外执行？？？。

我们来分析一下，大家都知道应用#define 时替换原则，我们替换一下

REGISTER_AF_OBJECT_CLASS(FirstB); ==》 AF_OBJECT::register_t<FirstB> __FirstB('FirstB", ##__VA_ARGS__);

呵，这货就是一个变量。而我们在变量的构造函数里面把他放入std::map<std::string, std::function<T*()>> _map;Map中！

1 int main()
2 {
3     AF_OBJECT::normal_ptr("SecondB")->display();
4     AF_OBJECT::shared_ptr("ThirdB")->display();
5     return 0;
6 }

 

posted @ 2019-01-08 17:04  Jolydong  阅读(1236)  评论(0)    收藏  举报