以类模板封装单例模式

第一种返回类的静态对象；第二种返回类的静态指针

template<typename T> class SingletonVar
{
public:
    SingletonVar() = default;
    SingletonVar(const SingletonVar&) = delete;
    SingletonVar& operator=(const SingletonVar&) = delete;
    ~SingletonVar() = default;

    static T& getInstance();
};

template<typename T> T& SingletonVar<T>::getInstance()
{
    static T inst;
    return inst;
}

template<typename T> class SingletonPtr
{
public:
    SingletonPtr() = default;
    SingletonPtr(const SingletonPtr&) = delete;
    SingletonPtr& operator=(const SingletonPtr&) = delete;
    ~SingletonPtr() = default;

    static T* getInstance();

private:
    static T* t_;
    static std::mutex mtx_;
};

template<typename T> T* SingletonPtr<T>::t_;

template<typename T> std::mutex SingletonPtr<T>::mtx_;

template<typename T> T* SingletonPtr<T>::getInstance()
{
    std::unique_lock<std::mutex> unique_locker(mtx_);
    if (t_ == nullptr)
        t_ = new T();
    return t_;
}

举例：

class SingletonClass: public SingletonPtr<SingletonClass>
{
	friend class SingletonPtr<SingletonClass>;

public:


private:
	Protocol();
	~Protocol();
};