c++11 template factory

自動註冊工廠CSDN裏已經有人解析過了，這裏是學習過程中的總結、並詳細解析。話不多說，先看代碼：

oly_auto_factory.h

#pragma once
#include <functional>
#include <map>
#include <memory>
#include <string>

namespace oly {
/**
 * T 需要傳入基類
 */
template <typename T>
class auto_factory {
public:
    /**
     * N 子類，這裏會把對應子類添加到Map中
     */
    template <typename N>
    struct register_t {
        template <typename... Args>
        register_t(const std::string& key, Args... args)
        {
            auto_factory::instance()->_map.emplace(key, [=] { return new N(args...); });
        }
    };

    /**
     * 普通指針
     */
    static auto normal_ptr(const std::string& key) -> T*
    {
        return auto_factory::instance()->find(key);
    }

    /**
     * unique_ptr指針
     */
    static std::unique_ptr<T> unique_ptr(const std::string& key)
    {
        return std::unique_ptr<T>(normal_ptr(key));
    }

    /**
     * shared_ptr指針
     */
    static std::shared_ptr<T> shared_ptr(const std::string& key)
    {
        return std::shared_ptr<T>(normal_ptr(key));
    }

private:
    auto_factory(){};
    auto_factory(const auto_factory&) = delete;
    auto_factory(auto_factory&&)      = delete;
    auto_factory& operator=(const auto_factory&) = delete;

    /**
     * 單例模式
     */
    static auto instance() -> auto_factory<T>*
    {
        static auto_factory<T> ins;
        return &ins;
    }

    auto find(const std::string& key) -> T*
    {
        if (_map.find(key) == _map.end())
            throw std::invalid_argument("key is not exist!");

        return _map[key]();
    }
    std::map<std::string, std::function<T*()>> _map;
};
}  // 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 

class FirstB : public B {
public:
    void display() override
    {
        std::cout << __func__ << " FirstB\n";
    }
};
REGISTER_AF_OBJECT_CLASS(FirstB);

class SecondB : public B {
public:
    SecondB(const std::string name = "")
    {
        nameString = name;
    }

    void display() override
    {
        std::cout << __func__ << " SecondB\n";
        std::cout << nameString << "\n";
    }

private:
    std::string nameString;
};
REGISTER_AF_OBJECT_CLASS(SecondB, "Welcome");  //帶參構造函數

class ThirdB : public B { 
public:
    ThirdB(int age, const std::string name = "")
    {
        nameString = name;
        ageInt     = age;
    }
    void display() override
    {
        std::cout << __func__ << " ThirdB\n";
        std::cout << nameString << ":" << ageInt << "\n";
    }

private:
    std::string nameString;
    int         ageInt;
};
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中！

int main()
{
    AF_OBJECT::normal_ptr("SecondB")->display();
    AF_OBJECT::shared_ptr("ThirdB")->display();
    return 0;
}