#ifndef MODULE_SINGLETON_BASE_H
#define MODULE_SINGLETON_BASE_H

#include<mutex>

template<typename T>
class singleton_base
{
public:
    static T *instance()
    {
        if(nullptr != _instance)
        {
            return _instance;
        }

        std::lock_guard<std::mutex> ll(_mutex_singleton_base);
        if(nullptr == _instance)
        {
            _instance = new(std::nothrow) T();
        }

        return _instance;
    }

protected:
    //使继承者无法public构造函数和析构函数
    singleton_base(){}
    //virtual ~singleton_base(){}
private:
    //禁止拷贝构造和赋值运算符
    singleton_base(const singleton_base&){}
    singleton_base &operator=(const singleton_base&){}

    //它的唯一工作就是在析构函数中析构Singleton的实例，所以private
    class Garbo
    {
    public:
        ~Garbo()
        {
            if (singleton_base::_instance)
            {
                delete singleton_base::_instance;
                singleton_base::_instance = nullptr;
            }
        }
    };
    //定义一个静态成员变量，程序结束时，系统会自动调用它的析构函数，我们不需要访问这个变量，所以不需要初始化
    static Garbo garbo;

    static T *_instance;
    static std::mutex _mutex_singleton_base;
};

template<typename T>
T *singleton_base<T>::_instance = nullptr;

template<typename T>
std::mutex singleton_base<T>::_mutex_singleton_base;



#endif // MODULE_SINGLETON_BASE_H