C++实现单例模式的自动释放

单例模式是为了确保某个类只能创建一个对象而设计的。当一个程序的某个类型只允许有一个实例的时候使用。

一般采用动态分配的方式来生成单例对象，这个时候c++程序员就需要考虑内存回收的问题了，所以为了避免在使用单例模式时忘记回收资源而造成内存泄漏的问题，在实现单例模式的时候就使其可以自动被回收。

不带自动释放的单例模式的实现与销毁

我们先来复习一下没有自动回收机制的单例模式的实现和销毁。

单例模式的实现：

• 将构造函数私有化
• 在类中定义一个静态的指向本类型的指针变量
• 定义一个返回值为该类的指针的静态成员函数，在类的外部调用该函数，生成单例对象。
  

单例模式的销毁：

不能在析构函数中释放那个指向本类型的指针变量
需要用静态的成员函数回收指向本类型的指针变量，然后在类的外部调用该成员函数来销毁该单例对象。

单例模式的自动释放

主要思想是，利用c++栈对象消亡是会自动回收的特点，来自动回收分配在堆上的单例对象，可以通过四种方法：友元类、内部类+静态数据成员、atexit()函数、pthread_once()+atexit()来实现

废话不多说，直接上代码。

1.借助友元类

//利用友元类，实现单例模式的自动释放

#include <stdio.h>
#include <iostream>

using std::cout;
using std::endl;
using std::cin;

class autorelease;

class singleton{
    //单例模式的类
public:
    static singleton *getinstance();//返回单例指针

private:
    friend class autorelease;
    singleton();  //构造函数和析构函数都得是private
    ~singleton();
    static singleton *_pinstance;
};

singleton *singleton::getinstance(){
    if(_pinstance == nullptr){
        _pinstance = new singleton();
    }
    return _pinstance;
}

singleton::singleton()
{
    cout << "singleton()" << endl;
}

singleton::~singleton(){
    cout << "~singleton()" << endl;
}

class autorelease{
    //用来实现单例的自动释放的类
    //应该保存在栈上，程序结束时自动回收单例的资源
public:
    autorelease(){
        cout << "autorelease()" << endl;
    }
    ~autorelease(){
        cout << "~autorelease()" << endl;
        if(singleton::_pinstance == nullptr){
            return;
        }
        delete singleton::_pinstance;
        singleton::_pinstance = nullptr;
    }
};

singleton *singleton::_pinstance = nullptr;  //饱汉模式

int main()
{
    singleton *s1 = singleton::getinstance();
    singleton *s2 = singleton::getinstance();
    autorelease at;
    printf("s1 = %p\n", s1);
    printf("s2 = %p\n", s2);
    s1 = nullptr;
    s2 = nullptr;
    return 0;
}

2.借助内部类和静态数据成员

//利用内部类，实现单例模式的自动释放

#include <stdio.h>
#include <iostream>

using std::cout;
using std::endl;
using std::cin;

class singleton{
    //单例模式的类
public:
    static singleton *getinstance();//返回单例指针

private:
    friend class autorelease;
    singleton();  //构造函数和析构函数都得是private
    ~singleton();
    static singleton *_pinstance;

private:
    //应该设计为私有类，避免类外的其他成员使用
    class autorelease{
        //用来实现单例的自动释放的内部类
        //应该保存在栈上，程序结束时自动回收单例的资源
    public:
        autorelease(){
            cout << "autorelease()" << endl;
        }
        ~autorelease(){
            cout << "~autorelease()" << endl;
            if(singleton::_pinstance == nullptr){
                return;
            }
            delete singleton::_pinstance;
            singleton::_pinstance = nullptr;
        }
    };

private:
    static autorelease _at;  //由于autorelease是private，所以对象应该放在静态区
};

singleton *singleton::getinstance(){
    if(_pinstance == nullptr){
        _pinstance = new singleton();
    }
    return _pinstance;
}

singleton::singleton()
{
    cout << "singleton()" << endl;
}

singleton::~singleton(){
    cout << "~singleton()" << endl;
}


/* singleton *singleton::_pinstance = nullptr;  //饱汉模式 */
//饱汉模式多线程时不安全，需要使用饿汉模式，在程序跑起来前就生成单例对象
singleton *singleton::_pinstance = singleton::getinstance();//饿汉模式
singleton::autorelease singleton::_at;

int main()
{
    singleton *s1 = singleton::getinstance();
    singleton *s2 = singleton::getinstance();
    printf("s1 = %p\n", s1);
    printf("s2 = %p\n", s2);
    s1 = nullptr;
    s2 = nullptr;
    return 0;
}

3.借助atexit()函数

//利用atexit函数，实现单例模式的自动释放

#include <stdio.h>
#include <iostream>

using std::cout;
using std::endl;
using std::cin;

class singleton{
    //单例模式的类
public:
    static singleton *getinstance();//返回单例指针
    static void destroy();

private:
    friend class autorelease;
    singleton();  //构造函数和析构函数都得是private
    ~singleton();
    static singleton *_pinstance;
};

singleton *singleton::getinstance(){
    if(_pinstance == nullptr){
        _pinstance = new singleton();
        //注册destroy函数，在进程结束的时候执行，从而自动回收单例
        atexit(singleton::destroy);
    }
    return _pinstance;
}

void singleton::destroy(){
    if(singleton::_pinstance == nullptr){
        return;
    }
    delete singleton::_pinstance;
    singleton::_pinstance = nullptr;
}

singleton::singleton()
{
    cout << "singleton()" << endl;
}

singleton::~singleton(){
    cout << "~singleton()" << endl;
}

//为了保证多线程情况下的安全性，使用饿汉模式
singleton *singleton::_pinstance = singleton::getinstance();  //饿汉模式

int main()
{
    singleton *s1 = singleton::getinstance();
    singleton *s2 = singleton::getinstance();
    printf("s1 = %p\n", s1);
    printf("s2 = %p\n", s2);
    s1 = nullptr;
    s2 = nullptr;
    return 0;
}

4.借助pthread_once和atexit函数

//利用pthread_once和atexit函数，实现单例模式的自动释放

#include <stdio.h>
#include <iostream>

using std::cout;
using std::endl;
using std::cin;

class singleton{
    //单例模式的类
public:
    static void init();
    static singleton *getinstance();//返回单例指针
    static void destroy();

private:
    friend class autorelease;
    singleton();  //构造函数和析构函数都得是private
    ~singleton();
    static pthread_once_t _once;
    static singleton *_pinstance;
};

void singleton::init(){
    //初始化单例，注册回收函数
    if(_pinstance == nullptr){
        _pinstance = new singleton();
        atexit(singleton::destroy);
    }
}

singleton *singleton::getinstance(){
    //执行pthread_once，保证在多线程的情况下创建单例对象的安全性
    pthread_once(&_once, init);

    return _pinstance;
}

void singleton::destroy(){
    if(singleton::_pinstance == nullptr){
        return;
    }
    delete singleton::_pinstance;
    singleton::_pinstance = nullptr;
}

singleton::singleton()
{
    cout << "singleton()" << endl;
}

singleton::~singleton(){
    cout << "~singleton()" << endl;
}

//由于已经使用了pthread_once来保证安全性，所以使用饱汉模式即可
singleton *singleton::_pinstance = nullptr;
/* singleton *singleton::_pinstance = singleton::getinstance();  //饿汉模式 */
pthread_once_t singleton::_once = pthread_once_init;

int main()
{
    singleton *s1 = singleton::getinstance();
    singleton *s2 = singleton::getinstance();
    printf("s1 = %p\n", s1);
    printf("s2 = %p\n", s2);
    s1 = nullptr;
    s2 = nullptr;
    return 0;
}

以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持。