使用可变参数模板创建单例模式

#ifndef BASE_SINGLETON_H
#define BASE_SINGLETON_H

#include <iostream>
#include <mutex>
#include "logger.h"
#include "base_exception.h"
#include "singleton_objects.h"

using namespace std;
namespace base {

//单例模式new出来的class 不需要手动进行释放
//进程退出时统一释放即可

    template<typename T>
    class Singleton {
    public:
        Singleton() {}

        ~Singleton() {}

        template<typename... Args>
        static T *Instance(Args &&... args) {
            if (p_instance_ == nullptr) {
                std::lock_guard<std::mutex> lock(mutex_);
                if (p_instance_ == nullptr) {

                    cout<<"开始创建单例 :"  << typeid(T).name() << endl;
                    auto p_object = new T(std::forward<Args>(args)...);

                    p_instance_ = new SingletonObject<T>(p_object);
                    SingletonObject<T>::RegistObject(p_instance_);
                }
            }

            return p_instance_->get_value();
        }

        static T *GetInstance() {
            if (p_instance_ == nullptr)
                throw Exception(-1, "the instance is not init, please initialize the instance first");
            return p_instance_->get_value();

        }

        static void DestroyInstance() {
            SingletonObject<T>::UnRegistObject(p_instance_);
            delete p_instance_;
            p_instance_ = nullptr;
        }

        Singleton(const Singleton &) = delete;

        Singleton &operator=(const Singleton &) = delete;

    private:
        static SingletonObject<T> *p_instance_;
        static std::mutex mutex_;
    };

    template<class T> SingletonObject<T> *Singleton<T>::p_instance_ = nullptr;
    template<class T> std::mutex Singleton<T>::mutex_;


    void DestroySingltonObjects();


}

#endif //BASE_SINGLETON_H

#include "singleton.h"

namespace base {

    void DestroySingltonObjects() {
        SingletonObjectBase::DestroySingletonObjects();
    }

}