单例对象的创建与自动释放

#include <iostream>
using std::cout;
using std::endl;



class Singleton
{
public:
    class AutoRelease
    {
    public:
        AutoRelease(Singleton * p)
        : _p(p) {    }

        ~AutoRelease() {    
            if(_p) {
                delete _p;
                _p = nullptr;
            }
        }
        Singleton * _p;
    };
public:
    static Singleton * getInstance()
    {
        if(_pInstance == nullptr) {
            _pInstance = new Singleton();
        }
        return _pInstance;
    }

    static void destroy()
    {
        if(_pInstance) {
            delete _pInstance;
            _pInstance = nullptr;
        }
    }

private:
    Singleton() {    cout << "Singleton()" << endl;    }
    ~Singleton() {    cout << "~Singleton()" << endl;    }

    int _data;
    static Singleton * _pInstance;
};

Singleton * Singleton::_pInstance = nullptr;

 
void test0() 
{
    Singleton * ps1 = Singleton::getInstance();
    Singleton * ps2 = Singleton::getInstance();
    printf("ps1:%p\n", ps1);
    printf("ps2:%p\n", ps2);
    Singleton::AutoRelease ar(ps1);

    //如果忘记了执行回收单例对象的操作，就会发生内存泄漏
    //Singleton::destroy();
} 
 
int main(void)
{
    test0();
    return 0;
}

#include <iostream>
using std::cout;
using std::endl;
  
//单例对象的自动释放方法一：
//嵌套类 + 静态对象
  
//外部类
class singleton
{
public:
class autorelease//内部类
{    //autorelease专为singleton服务
public:
      //在内部类内部无法直接拿到外部类的
      //非静态的数据成员的
      autorelease()
      {    
          //cout << _data << endl;//error
          cout << "autorelease()" << endl;
      }
  
      //在autorelease内部是可以直接拿到外部类的
      //静态数据成员_pinstance
      ~autorelease() {    
          if(_pinstance) {
              delete _pinstance;
              _pinstance = nullptr;
          }
          cout << "~autorelease()" << endl;
      }
      singleton * _p;
};
public:
static singleton * getinstance()
{
      if(_pinstance == nullptr) {
          _pinstance = new singleton();
      }
      return _pinstance;
}
  
static void destroy()
{
      if(_pinstance) {
          delete _pinstance;
          _pinstance = nullptr;
      }
}
  
private:
    singleton()
    {    cout << "singleton()" << endl;    }
    ~singleton() {    cout << "~singleton()" << endl;    }
  
    int _data;
    static autorelease _ar;//类对象成员
    static singleton * _pinstance;
};
  
singleton * singleton::_pinstance = nullptr;
//静态数据成员要在类之外初始化
singleton::autorelease singleton::_ar;
  
   
void test0() 
{
    //在getinstance之中创建autorelease对象
    singleton * ps1 = singleton::getinstance();
    singleton * ps2 = singleton::getinstance();
    printf("ps1:%p\n", ps1);
    printf("ps2:%p\n", ps2);
    //需求: 该语句不需要我们手动执行
    //singleton::autorelease ar(ps1);
  
    //如果忘记了执行回收单例对象的操作，就会发生内存泄漏
    //singleton::destroy();
} 
   
int main(void)
{
    test0();
    return 0;
}

 

#include <stdlib.h>
#include <iostream>
using namespace std;

class Singleton
{
public:
    static Singleton * getInstance()
    {
        if(_pInstance == nullptr) {
            _pInstance = new Singleton();
            atexit(destroy);
        }
        return _pInstance;
    }
private:
    Singleton() {    cout << "Singleton()" << endl;    }
    ~Singleton() {    cout << "~Singleton()" << endl;    }
    int _data;
    static Singleton * _pInstance;
};
//饿汉模式
Singleton * Singleton::_pInstance = getInstance();
void test0() 
{
    Singleton * ps1 = Singleton::getInstance();
    Singleton * ps2 = Singleton::getInstance();
    printf("ps1:%p\n", ps1);
    printf("ps2:%p\n", ps2);
} 
int main(void)
{
    test0();
    return 0;
}

#include <stdlib.h>
#include <pthread.h>
#include <iostream>
using std::cout;
using std::endl;
class Singleton
{
public:
    static Singleton * getInstance()
    {    //多线程安全的实现，但只能在Linux平台使用
        pthread_once(&_once, init);
        return _pInstance;
    }
    static void init()
    {
        atexit(destroy);    
        _pInstance = new Singleton();
    }

    static void destroy()
    {
        if(_pInstance) {
            delete _pInstance;
            _pInstance = nullptr;
        }
    }

private:
    Singleton() {    cout << "Singleton()" << endl;    }
    ~Singleton() {    cout << "~Singleton()" << endl;    }

    int _data;
    static Singleton * _pInstance;
    static pthread_once_t _once;
};

Singleton * Singleton::_pInstance = nullptr;
pthread_once_t Singleton::_once = PTHREAD_ONCE_INIT;
 
void test0() 
{
    Singleton * ps1 = Singleton::getInstance();
    Singleton * ps2 = Singleton::getInstance();
    printf("ps1:%p\n", ps1);
    printf("ps2:%p\n", ps2);
} 
 
int main(void)
{
    test0();
    return 0;
}