设计模式--单例模式

单例模式

单例模式是一种对象创建型模式，使用单例模式可以保证为每一个类只生成唯一的实例对象，也就是说在整个程序运行过程中只存在唯一的一个类对象。

---

应用场景：window里面的任务管理器就是典型的单例模式。

---

懒汉式

（需要自己调用）
代码如下

#include <iostream>
using namespace std;

class Singleton
{
private:
    Singleton(){
        cout<<"执行构造函数"<<endl;
    }

public:
    static Singleton* GetSingleton(){
        if(m_psingleton == nullptr)
        {
            m_psingleton = new Singleton;
        }
        return m_psingleton;
    }
    static void* FreeInstance(){
        if(m_psingleton != nullptr)
        {
            delete m_psingleton;
            m_psingleton = nullptr;
        }
    }
    static Singleton *m_psingleton;
};
Singleton* Singleton::m_psingleton = nullptr;
int main() {
    
    Singleton *p1 = Singleton::GetSingleton();
    Singleton *p2 = Singleton::GetSingleton();
    if (p1 == p2)
    {
        cout<<"单例模式是产生同一个对象"<<endl;
    }
    else
        cout<<"单例模式是产生了两个对象"<<endl;
    Singleton::FreeInstance();
    return 0;
}

懒汉式每次调用的时候都需要判断一下是否存在这样的对象。
懒汉式存在的问题：需要注意，他需要自己去new
多线程同时执行new时会产生多个对象。
一般需要加锁处理！！！！！！！！
而饿汉式已经new了不存在这样的问题了。

---

饿汉式

class Singleton{
private:
    Singleton(){
        cout<<"调用饿汉式单例模式"<<endl;
    }                                   // 构造函数在私有化，智能产生一个类对象
    
    static Singleton* m_singleton ;
    
public:
    static Singleton* GetSingleton(){
        return m_singleton;
    }
   static void* FreeSingleton()
    {
        if(m_singleton != nullptr)
        {
            cout<<"已经释放唯一的一个对象了"<<endl;
            delete m_singleton;
            m_singleton = nullptr;
        }
    }
};
 Singleton* Singleton::m_singleton = new Singleton;

int main(){
    Singleton* p1 = Singleton::GetSingleton();
    Singleton* p2 = Singleton::GetSingleton();
    if(p1 == p2)
    {
        cout<<"饿汉式单例模式类只存在一个对象"<<endl;
    }
    else
        cout<<"饿汉式单例模式类产生了两个对象"<<endl;
    Singleton::FreeSingleton();
    return 0;
}

饿汉式的缺点是：无论什么你用不用这样的对象都产生了一个这样的类对象，浪费内存。
new了对象一定要记得delete掉，不然像我一样犯了个大错误。
扫地僧：

重点：饿汉式static 对象什么时候创建的呢？static类内声明类外定义
在类外new了一个对象，其实进入mian（）函数第一件事就是处理全局变量。