单例模式-析构函数的深入理解

singleton单例模式 单件模式

     保证一个类中仅有一个实例,并且提供一个访问他的全局访问点
a. 懒汉式：使用的时候才创建，多线程访问的时候线程不安全(双检锁)
b. 饿汉式：类文件加载的时候已经创建好了对象，如果对象一直没有使用，则类对象浪费空间

#注意
    1. 构造函数私有化， 
    2. 私有的静态类指针指向类的实例（类外声明）
    3. 共有的静态方法去获取一个访问实例的访问点
    4. 析构函数需要定义一个嵌套类的析构函数去释放单例
   5. 绝对不要在单例的析构函数中释放单例(coredump)!!!!!!!!! 详情看下面有问题的单例代码

#include <iostream>using namespace std;class A{    private:        static A *m_p;    public:        static A *getSingleTon()        {            if(NULL == m_p)            {                m_p = new A();            }            return m_p;        }/*        ~A()        {            if(NULL != m_p)            {                cout << "xxx" << endl;                delete m_p; // 递归调用析构                m_p = NULL;                cout << "yyy" << endl; // 永远也不会执行            }        }*/};A* A::m_p = NULL;int main(){    A *p = A::getSingleTon();    delete p;    return 0;}

所以单例析构函数：定义一个静态的嵌套类对象的析构函数去析构单例对象，简单思想看如下代码：

#include<iostream>using namespace std;//嵌套类去析构单例类对象class A{    public:    ~A()    {        cout << "deconstructor A" << endl;    }    class B    {        public:        ~B()      //嵌套类成员的析构函数去析构单例函数的对象        {            cout << "调用嵌套 deconstructor B" << endl;         }    };    private:    static  B b;    static int a;};int  A::a = 10;A::B A::b;        //嵌套静态类成语,必须类外声明int main(){    return 0;}

需要清楚一下几点：

 

1、单例中的 new 的对象需要delete释放。

 

2、delete释放对象的时候才会调用对象的析构函数。

 

3、如果在析构函数里调用delete，那么程序结束时，根本进不去析构函数，怎么会delete。

 

4、如果程序结束能自动析构，那么就会造成一个析构的循坏，所以new对应于delete。

/////////////////////////////////////////////////////////////////////////////////////////////////

A.懒汉式单例模式

//懒汉式 （创建的时候采取new实例）以时间换取空间，线程不安全class singleton_L{    public:        static singleton_L* getinstance()        {            if(instance == NULL)            {                instance = new singleton_L();            }            return instance;        }                //实际上在析构函数中析构对象是一种错误的做法,会调用,切是一个死递归,正确做法是创建一个嵌套的析构类        /*~singleton_L()        {            if(instance != NULL)            {                delete instance;                instance = NULL;            }                    cout << "~singleton_L()" << endl;        }*/    private:        class Garbo //设置为私有防止外界访问        {            public:                ~Garbo()//实际去析构new的单例对象                {                    if(singleton_L::instance != NULL)                    {                        cout << "delete singleton" << endl;                        delete singleton_L::instance;                        singleton_L::instance = NULL;                    }                }        };        private:        singleton_L(){}        static singleton_L*  instance;  //单例唯一实力        static Garbo garbo;             //静态私有的嵌套类对象,防止被外界访问};singleton_L*       singleton_L::instance = NULL;singleton_L::Garbo singleton_L::garbo;  //静态类对象类外声

B懒汉式 ，线程安全方法

//懒汉式 线程安全式（双检锁）/*  所谓双重检查加锁机制，指的是：并不是每次进入getInstance方法都需要同步，而是先不同步，进入方法过后，先检查实例是否存在，如果不存在才进入下面的同步块，这是第一重检查。进入同步块过后，再次检查实例是否存在，如果不存在，就在同步的情况下创建一个实例，这是第二重检查。这样一来，就只需要同步一次了，从而减少了多次在同步情况下进行判断所浪费的时间。*/class singleton_L_Lock{    public:        static singleton_L_Lock* getinstance()        {            if(instance == NULL)            {                pthread_mutex_lock(&mutex);  //加锁                if(instance == NULL)                    instance = new singleton_L_Lock();                pthread_mutex_unlock(&mutex);            }            return instance;        }    private:        class GGGarbo        {            public:                ~GGGarbo()                {                    if(singleton_L_Lock::instance != NULL)                    {                        delete singleton_L_Lock::instance;                        singleton_L_Lock::instance = NULL;                    }                }        };    public:        static pthread_mutex_t mutex;    private:        singleton_L_Lock()        {            pthread_mutex_init(&mutex, NULL);        }    private:        static singleton_L_Lock*  instance;        static GGGarbo gggarbo;};singleton_L_Lock* singleton_L_Lock::instance = NULL;pthread_mutex_t   singleton_L_Lock::mutex;  singleton_L_Lock::GGGarbo singleton_L_Lock::gggarbo;

c.饿汉式 ，不牵扯线程安不安全，以空间换时间

//饿汉式（在定义实例的时候就去new对象）以空间换时间class singleton_E{    public:        static singleton_E* getinstance()        {            return instance;        }       // ~singleton_E(){}        class GGarbo        {            public:                ~GGarbo()                {                    if(singleton_E::instance != NULL)                    {                        cout << "delete singleton_E" << endl;                        delete singleton_E::instance;                        singleton_E::instance = NULL;                    }                }        };    private:        singleton_E(){}        static singleton_E* instance;        static GGarbo ggarbo;};singleton_E*        singleton_E::instance = new singleton_E();singleton_E::GGarbo singleton_E::ggarbo;

以上就是我对单例模式的一些理解心得，如有不对的地方多多指教，哈哈哈。