单例模式

单例模式作用

1.只能创建一个对象，节约资源。
2.保证他是唯一的实例，有些设计需要在不同的模块调用同一个实例对象。

懒汉式

线程安全的懒汉式-单例模板

#include <mutex>

template <class T>
class Singleton
{
public:
    static T* GetSingleton()  //设计为静态成员函数：目的是在外部不用实例化对象，即可获得该单例
    {
        if(pSingleton == nullptr)  //第一个if判断：判断单例是否创建，创建了就跳出
        {
         	//线程锁：若同时有多个线程进入第一个if想创建对象，则需要排队。
         	//如果没有线程锁，同时有多个线程进入if判断，先后new了对象。前面new的对象的地址
         	//会被后面new的对象的地址覆盖，导致前面的new的对象造成内存泄漏。
            mxt.lock();            
            if(pSingleton == nullptr) //排队的线程，如果已经有一个创建了后面的判断一下，就不用再创建，直接跳出。
            {
                pSingleton = new T();
            }
            mxt.unlock();
        }
        return pSingleton;
    }

    static void Destroy()   //销毁单例
    {
        mxt.lock();
        if (pSingleton != nullptr)
        {
            delete pSingleton;
            pSingleton = nullptr;
        }
        mxt.unlock();
    }

private:
    static T* pSingleton;
    static std::mutex  mxt;
};

template <class T>
std::mutex Singleton<T>::mxt;

template <class T>
T* Singleton<T>::pSingleton = nullptr;

使用单例模板的类

#include "Singleton/Singleton.h"

class GirlFriend
{
public:
    friend class Singleton<GirlFriend>; //因为单例类的构造函数为protected/private，因此外部需要调用它需要成员它的友元类。

    void show() const
    {
        std::cout << "身高：" << height << std::endl;
        std::cout << "年龄：" << age  << std::endl;
    }

private:
    GirlFriend() = default; //需要构建成单例的类，它的构造函数需要声明为protected/private类型，防止设计者在外部直接创建对象。即严格控制该类对象的创建方式。
    ~GirlFriend() = default;
    int age = 18;
    int height = 166;
};

main.cpp

#include <iostream>
#include "GirlFriend/GirlFriend.h"
#include "Singleton/Singleton.h"


int main() {
    Singleton<GirlFriend>::GetSingleton()->show();
    std::cout << "Hello, World!" << std::endl;
    return 0;
}