设计模式之单例模式

设计模式之单例模式：

　　单例模式：只能有一个实例，实例的初始化要考虑线程安全，不允许构造。

　　实现： 利用static的特性实现，使用new+锁，或者直接定义变量实现线程安全，使用类内析构的方式实现new对象的析构

/*********************************************************************************
1：设计模式单例的实现
　　　　单例的特性，只允许构造一次，然后后面再次构造的时候不能新建，需要重新使用。
　　　　线程安全，利用类的析构，保证一次释放内存。
1：利用static的特性：
　　　　进程内存有个栈区，堆区，全局区，常量区，代码区
　　　　静态局部变量，全局变量，只能在本文件内访问，可修饰变量，函数 ==》装载时初始化
2：实现代码
　　　　分为懒汉和饿汉模式 初始化和直接构造 ，禁止外部构造
*********************************************************************************/

#include <iostream>
#include <mutex>
using namespace std;
class A
{
private:
    int a;
    int b;
public:
    A(const A& arg) // 拷贝构造函数  
    {
        a = arg.a;
        b = arg.b;
    }
    A& operator = (const A& arg) //重载的赋值函数 
    {
        if (this != &arg)// 先判断下是否是自身赋值
        {
            a = arg.a;
            b = arg.b;
        }
        return *this;
    }
};


class singleton {
private:
    singleton() = default;
    singleton(const singleton&) = delete;

    ~singleton() = default;
public:
    singleton& operator = (const singleton& w) = delete;
    static singleton m_sig;

public:
    static singleton* GetInstence()
    {
        return &m_sig;
    }
};
singleton singleton::m_sig;

class Singleton1 {
private:
    Singleton1() = default;
    Singleton1(const Singleton1&) = delete;
    Singleton1& operator = (const Singleton1&) = delete;
    ~Singleton1() = default;
public:
    static Singleton1* GetInstence()
    {
        static Singleton1 m_sig;
        return &m_sig;
    }
};

//利用static定义唯一，利用类实现释放
class Singleton2 {
private:
    Singleton2() = default;
    Singleton2(const Singleton2&) = delete;
    Singleton2& operator=(const Singleton2&) = delete;
    ~Singleton2() = default;
    class freeSig
    {
    public:
        ~freeSig()
        {
            if (m_sig != nullptr)
            {
                delete m_sig;
                m_sig = nullptr;
            }
        }
    };
private:
    //加锁
    static Singleton2* m_sig;
    static mutex m_mtx;
    static class freeSig m_free;
public:
    //内部调用静态变量 所以用static
    static Singleton2* GetInstence()
    {
        //m_sig = new Singleton2();
        //return m_sig;
        if (Singleton2::m_sig == nullptr)
        {
            Singleton2::m_mtx.lock();
            if (Singleton2::m_sig == nullptr)
            {
                Singleton2::m_sig = new Singleton2();
            }
            Singleton2::m_mtx.unlock();
        }
        return Singleton2::m_sig;
    }
};
//外部初始化
Singleton2* Singleton2::m_sig = nullptr;
mutex Singleton2::m_mtx;
Singleton2::freeSig Singleton2::m_free;
int main()
{
    singleton* s = singleton::GetInstence();
    Singleton1* s1 = Singleton1::GetInstence();
    Singleton2* s2 = Singleton2::GetInstence();
    return 0;
}