自学内容网 自学内容网
自学内容网 > 正文

C++单例模式实现

🕗 发布于 2024-11-14 07:06 c++  单例模式  开发语言  

单例模式（Singleton Pattern）是软件设计模式中的一种，用于确保一个类只有一个实例，并提供一个全局访问点来获取这个实例。

一、初始版本（手动创建释放）

一个类只有一个实例的实现方法：

  • 隐藏构造函数，是外界无法创造对象
  • 通过类静态成员函数getInstance返回静态局部对象指针（指向堆空间的指针数据成员），确保对象生命周期和程序一致，并且在程序中唯一
  • 使用destory释放堆空间
#include <iostream>
using std::cout;
using std::endl;

class Singleton{
public:
    static Singleton *getInstance(){
        if(_pInstance==nullptr){
            _pInstance=new Singleton();
        }
        return _pInstance;
    }
    static void destory(){
        if(_pInstance){
            delete _pInstance;
            _pInstance=nullptr;
        }
    }
private:
    Singleton(){}
    static Singleton *_pInstance;
    int data;

};
Singleton *Singleton::_pInstance=nullptr;
int main()
{
    cout<<Singleton::getInstance()<<endl;
    cout<<Singleton::getInstance()<<endl;
    Singleton::destory();
    return 0;
}

缺点：

需要人为手动释放堆空间，容易疏忽造成内存泄露

二、RAII思想

RAII（Resource Acquisition Is Initialization）是一种编程思想，主要用于C++等需要手动管理资源的语言中。RAII的核心思想是将资源的生命周期与对象的生命周期绑定，通过对象的构造函数来获取资源，通过析构函数来释放资源。这样做的好处是，当对象超出作用域并被销毁时，其析构函数会自动被调用，从而释放资源，避免了内存泄漏和其他资源泄露的问题。

RAII的主要特点包括：

  • 资源获取即初始化：在对象构造时获取所需的资源，如内存、文件句柄、网络连接等。
  • 自动资源释放：对象在超出作用域后自动调用析构函数，释放在构造函数中获取的资源。

三、利用RAII思想实现自动释放

 1、利用另一个对象的生命周期管理资源

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


class Singleton{
public:
    static Singleton *getInstance(){
        if(_pInstance==nullptr){
            _pInstance=new Singleton();
        }
        return _pInstance;
    }
    static void destory(){
        if(_pInstance){
            delete _pInstance;
            _pInstance=nullptr;
        }
    }
private:
    Singleton(){}
    static Singleton *_pInstance;
    int data;

};
Singleton *Singleton::_pInstance=nullptr;
class AutoRelease{
public:
    AutoRelease(){}
    ~AutoRelease(){
        Singleton::destory();
    }
};
int main()
{
    AutoRelease autoRls=AutoRelease();
    cout<<Singleton::getInstance()<<endl;
    cout<<Singleton::getInstance()<<endl;
    return 0;
}

缺点：仍然需要手动做额外的事情。

改进：嵌套类

2、嵌套类

Singleton中嵌套AutoRelease类，定义一个静态的AutoRelease成员_ar，创建Singleton对象自动产生一个AutoRelease对象，程序结束时会销毁全局静态区中的_ar，调用AutoRelease的析构函数，释放资源。

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

class Singleton{
public:
    static Singleton *getInstance(){
        if(_pInstance==nullptr){
            _pInstance=new Singleton();
        }
        return _pInstance;
    }
    static void destory(){
        if(_pInstance){
            delete _pInstance;
            _pInstance=nullptr;
        }
    }
private:
    class AutoRelease{
    public:
        AutoRelease(){}

        ~AutoRelease(){
            destory();
        }
    };
    Singleton(){}
    static Singleton *_pInstance;
    int data;
    static AutoRelease _ar;
};
Singleton *Singleton::_pInstance=nullptr;
Singleton::AutoRelease Singleton::_ar;
int main()
{
    cout<<Singleton::getInstance()<<endl;
    cout<<Singleton::getInstance()<<endl;
    return 0;
}

四、使用atexit函数释放资源

atexit 函数是 C 语言标准库中的一个函数，用于在程序正常退出时注册一个函数，以便在程序结束时自动调用。

int atexit(void (*function)(void));
  • function 参数是一个函数指针，指向一个不带参数且没有返回值的函数 
#include <iostream>
using std::cout;
using std::endl;

class Singleton{
public:
    static Singleton *getInstance(){
        if(_pInstance==nullptr){
            _pInstance=new Singleton();
        }
        return _pInstance;
    }
    static void destory(){
        if(_pInstance){
            delete _pInstance;
            _pInstance=nullptr;
        }
    }
private:
    Singleton(){
        atexit(destory);
    }
    static Singleton *_pInstance;
    int data;

};
Singleton *Singleton::_pInstance=nullptr;
int main()
{
    cout<<Singleton::getInstance()<<endl;
    cout<<Singleton::getInstance()<<endl;
    return 0;
}

五、线程安全

以上实现方式均为懒汉式，在多线程情况下可能会创建多个堆空间，而_pInstance只能指向一个，造成内存泄露。

Singleton *Singleton::_pInstance=nullptr;//懒汉式

可以使用饿汉式在程序最开始就创建,但这样可能带来内存压力。

Singleton *Singleton::_pInstance=getInstance();

使用pthread_once和atexit保障初始化代码只执行一次 ，实现线程安全

pthread_once 是 POSIX 线程库中的一个函数，用于在多线程环境中确保某个初始化函数只执行一次。这个函数特别有用，当你需要在程序启动时进行一些初始化操作，但又希望这些操作只执行一次，即使有多个线程同时尝试执行它们。

int pthread_once(pthread_once_t *once_control, void (*init_routine)(void));
  • once_control 是一个控制变量，必须指向一个初始化为 PTHREAD_ONCE_INIT 的 pthread_once_t 类型的静态或全局变量。
  • init_routine 是一个函数指针，指向一个不带参数且没有返回值的函数，这个函数包含了初始化代码。
#include <iostream>
#include<pthread.h>
using std::cout;
using std::endl;

class Singleton{
public:
    static Singleton *getInstance(){
        pthread_once(&_once,init);
        return _pInstance;
    }
    static void init(){
        _pInstance=new Singleton();
        atexit(destory);
    }
    static void destory(){
        if(_pInstance){
            delete _pInstance;
            _pInstance=nullptr;
        }
    }
private:
    Singleton(){}
    static Singleton *_pInstance;
    int data;
    static pthread_once_t _once;
};
Singleton *Singleton::_pInstance=nullptr;
pthread_once_t Singleton::_once=PTHREAD_ONCE_INIT;

int main()
{
    cout<<Singleton::getInstance()<<endl;
    cout<<Singleton::getInstance()<<endl;
    return 0;
}


原文地址：https://blog.csdn.net/weixin_73809064/article/details/143711845

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！

相关文章

自学内容网
Copyright © 2015-2024