单例模式

最新推荐文章于 2024-05-02 17:01:34 发布
最新推荐文章于 2024-05-02 17:01:34 发布
阅读量172 收藏
点赞数
分类专栏： C++笔记 文章标签： 设计模式 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Firenze__/article/details/107399315
版权

单例模式

单例模式是23种GOF模式中最简单的设计模式之一，属于创建型模式，它提供了一种创建对象的方式， 确保只有单个对象被创建。这个设计模式主要目的是想在整个系统中只能出现类的一个实例，即一个类只有一个对象。

现步骤有如下三步:

  1. 将构造函数私有化
  2. 在类中定义一个静态的指向本类型的指针变量
  3. 定义一个返回值为类指针的静态成员函数

一、单例模式的手动释放：

//单例模式的要求：一个类只能创建一个对象
//不能是栈对象，不能是全局对象，只能是堆对象  栈对象、全局对象系统自动分配空间
//
//用途：全局唯一的资源，全局唯一变量
//字典库、词典库、网页库、日志系统记录日志的对象

class Singleton
{
public:
    //静态成员函数可以在类外不创建类的对象而调用类中的函数
    static Singleton *getInstance()
    {
        if(nullptr == _pInstance)
        {
            _pInstance = new Singleton();//类的内部访问构造函数
        }
        return _pInstance;
    }
    static void destroy()
    {
        if(_pInstance)
        {
            //delete的工作机制  1.调用析构函数  2.operator delete 
        	delete _pInstance; //调用private中的析构函数
      		_pInstance = nullptr;
        } 
    }
private:
    //构造函数私有，不能在类的外面访问
    Singleton()
    {
        cout << "Singleton()" << endl;
    }
    ~Singleton()  //析构函数放在private里面，只能类内调用			  
    {
        cout << "~singleton()" << endl;
    }
private:
    //仅是声明，没有定义
    //static int *s1;
    static Singleton *_pInstance; //静态成员函数需要静态的成员
};

//类外的定义才是给静态成员变量分配空间
// int *s1 = nullptr;
Singleton * Singleton::_pInstance = nullptr;//静态成员进行初始化

//Singleton gS1;//全局对象，error，不能让其编译通过，只能让构造函数私有
//Singleton gS2;//全局对象

int main()
{
    //Singleton s1;//栈对象，error，不能让其编译通过，只能让构造函数私有
    //Singleton s2;//栈对象
    //Singleton *ps1 = new Singleton(); //堆对象。类的外面创建不行，构造函数为私有
    
    Singleton *ps1 = Singleton::getInstance();
    Singleton *ps2 = Singleton::getInstance();
    cout << "ps1 = " << ps1 << endl
         << "ps2 = " << ps2 << endl;
    
    //delete ps1;  //new两次指向同一空间,delete两次的时候会出现两次析构函数
    //delete ps2;  //把放入private中，就只能类内调用了
    Singleton::destory();
    return 0;
}

结果： 
Singleton()
0x55ef6d254e70
0x55ef6d254e70
~Singleton()

  • Singleton::getInstance(); //创建对象

  • singleton::destory(); //销毁对象

  • 从整个进程来看，main函数结束，对象也就随程序的结束而销毁了，那还为什么要自己释放呢？

    • 堆对象只new，不去delete的话，会造成内存泄漏。内存泄漏很有可能造成程序的崩溃，所以要进行释放。
    • 如果没有自己释放，用内存检测工具进行检查的时候，就错误的认为单例模式需要进行释放

二、单例模式的自动释放：

  • 要想自动释放，而不是手动的调用singleton::destory()函数来对对象进行释放，需要想一下什么函数可以自动调用，不需要人为的操作？
    • 构造函数、析构函数是自动调用的。可以再定义一个类AutoRelease，在类AutoRelease的析构函数释放单例模式的对象（delete _pInstance），通过类AutoRelease的栈对象随着程序的结束而调用类AutoRelease的析构函数，从而释放单例模式的对象（delete _pInstance），进而使单例模式自动释放。
    • 再定义的这个类要想访问单例模式的对象_pInstance，有两种方法：1.友元函数 2.内部类

1、再定义的类AutoRelease设为Singleton的友元函数

#include <iostream>

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

//1、友元实现单例对象的自动释放
class AutoRelease;
class Singleton
{
public:
    friend AutoRelease;
    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;
    }
private:
    static Singleton *_pInstance;
    
};

Singleton *Singleton::_pInstance = nullptr;

class AutoRelease
{
public:
    AutoRelease()
    {
        cout << "AutoRelease()" << endl;
    }
    ~AutoRelease()
    {
        if(Singleton::_pInstance)
        {
            cout << "~AutoRelease()" << endl;
            //delete的工作机制  1.调用析构函数  2.operator delete
            delete Singleton::_pInstance;   
            Singleton::_pInstance = nullptr;
        }
    }
};

void test()
{
    Singleton *s1 = Singleton::getInstance();
    Singleton *s2 = Singleton::getInstance();
    cout << s1 << endl 
        << s2 << endl;
    /* Singleton::destroy(); */
    AutoRelease ar;  //通过栈对象ar的自动销毁，从而调用析构函数，进而自动释放单例对象
}

int main()
{
    test();
    return 0;
}

结果：
    
Singleton()
0x5597d5c0de70
0x5597d5c0de70
AutoRelease()
~AutoRelease()
~Singleton()

2、再定义的类AutoRelease嵌套在Singleton的里面

#include <iostream>

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

//2、内部类 + 静态成员  实现单例对象的自动释放
//为什么用静态成员？ 往下看51行
class AutoRelease;
class Singleton
{
public:
    static Singleton *getInstance()
    {
        if(_pInstance == nullptr)
        {
            _pInstance = new Singleton();
        }
        return _pInstance;
    }
private:
    Singleton()
    {
        cout << "Singleton()" << endl;
    }
    ~Singleton()
    {
        cout << "~Singleton()" << endl;
    }
private:
    class AutoRelease
    {
    public:
        AutoRelease()
        {
            cout << "AutoRelease()" << endl;
        }
        ~AutoRelease()
        {
            if(Singleton::_pInstance)
            {
                cout << "~AutoRelease()" << endl;
                //delete的工作机制  1.调用析构函数  2.operator delete
                delete Singleton::_pInstance;   
                Singleton::_pInstance = nullptr;
            }
        }
    };

private:
    static Singleton *_pInstance;
    /* AutoRelease _ar; */
    //为什么是静态变量？  
    //因为不是静态变量的时候，_ar是_pInstance对象的成员，_pInstace的销毁才会使_ar销毁，
    //但是由于_ar没有销毁,无法调用析构函数来销毁_pInstace，陷入了死循环
    //AutoRelease()
    //Singleton()
    //0x562be2b9ae70
    //0x562be2b9ae70
    static AutoRelease _ar;
};

//静态变量的定义,不是指针的可以不用赋值。
Singleton::AutoRelease Singleton::_ar;
Singleton *Singleton::_pInstance = nullptr;


void test()
{
    Singleton *s1 = Singleton::getInstance();
    Singleton *s2 = Singleton::getInstance();
    cout << s1 << endl 
        << s2 << endl;
}

int main()
{
    test();
    return 0;
}

结果：
    
AutoRelease()
Singleton()
0x558fc3972280
0x558fc3972280
~AutoRelease()
~Singleton()
  • 自动释放单例对象除了上面的两种办法外，还有两种办法： 3.利用atexit函数 4.利用pthread_once函数

3、利用atexit函数，这个函数的参数是传入一个函数，作用是把这个函数放到程序的最后，在结束之前运行

#include <iostream>
#include <stdlib.h>

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

//3、atexit + 饿汉模式
class Singleton
{
public:
    static Singleton *getInstance()
    {
        //如果不是饿汉模式的话，对于多线程环境来讲，不安全
        //多个线程能够都进来，可以创建多个对象（多个new Singleton()）,可能只销毁一个对象
        //会造成内存泄漏，有可能使程序崩溃
        //造成这个效果的主要原因是：_pInstance最开始是nullptr,有可能多个线程都可以进来
        if(_pInstance == nullptr)
        {
            _pInstance = new Singleton();
            atexit(destroy);

        }
        return _pInstance;
    }
    static void destroy()
    {
        if(_pInstance)
        {
            delete _pInstance;
            _pInstance = nullptr;
        }
    }
private:
    Singleton()
    {
        cout << "Singleton()" << endl;
    }
    ~Singleton()
    {
        cout << "~Singleton()" << endl;
    }
private:
    static Singleton *_pInstance;
    
};

/* Singleton *Singleton::_pInstance = nullptr; */   //饱汉模式or懒汉模式(上来不吃资源)
Singleton *Singleton::_pInstance = getInstance();   //饿汉模式(一上来就要吃资源)


void test()
{
    Singleton *s1 = Singleton::getInstance();
    Singleton *s2 = Singleton::getInstance();
    cout << s1 << endl 
        << s2 << endl;
    /* Singleton::destroy(); */
}

int main()
{
    test();
    return 0;
}

结果：

Singleton()
0x55b8ca7bae70
0x55b8ca7bae70
~Singleton()

4、pthread_once函数和线程库有关， 编译时加 -lpthread

#include <iostream>
#include <pthread.h>
#include <stdlib.h>

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

//4、pthread_once只会执行一次  平台相关性的函数
// pthread_once_t once_control = PTHREAD_ONCE_INIT;
// int pthread_once(pthread_once_t *once_control, void (*init_routine) (void))
class Singleton
{
public:
    static Singleton *getInstance()
    {
        pthread_once(&_once, init);
        return _pInstance;
    }
    static void init()
    {
            _pInstance = new Singleton();
            atexit(destroy);
    }
    static void destroy()
    {
        if(_pInstance)
        {
            delete _pInstance;
            _pInstance = nullptr;
        }
    }
private:
    Singleton()
    {
        cout << "Singleton()" << endl;
    }
    ~Singleton()
    {
        cout << "~Singleton()" << endl;
    }
private:
    static Singleton *_pInstance;
    static pthread_once_t _once;
    
};

Singleton *Singleton::_pInstance = nullptr;    //饱汉模式or懒汉模式(上来不吃资源)
/* Singleton *Singleton::_pInstance = getInstance();   //饿汉模式(一上来就要吃资源) */
pthread_once_t Singleton::_once = PTHREAD_ONCE_INIT;

void test()
{
    Singleton *s1 = Singleton::getInstance();
    Singleton *s2 = Singleton::getInstance();
    cout << s1 << endl 
        << s2 << endl;
    /* Singleton::destroy(); */
}

int main()
{
    test();
    return 0;
}

结果：
    
Singleton()
0x558a003cbe70
0x558a003cbe70
~Singleton()
Firenze__
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
43丨单例模式（下）：如何设计实现一个集群环境下的分布式单例模式？1
08-03
2020-02-10 王争设计模式之美进入课程讲述：冯永吉时长 10:21大小 8.31M上两节课中，我们针对单例模式，讲解了单例的应用场景、几种常见的代码实现
出现单实例模式毁坏Destroying singletons
luoxuefeihualzq的博客
05-07 3935
org.springframework.beans.factory.support.DefaultSingletonBeanRegistry destroySingletons 信息: Destroying singletons in org.springframework.beans.factory.support.DefaultListableBeanFactory@13d740f: d
单例模式需要释放吗
yuanya的专栏
10-16 4750
Ｑ：单例模式需要释放吗 Ａ1：这个问题我也想过，既然是单例，就是不管调用者什么时候调用，你必须马上给他返回一个实例，所以，在整个程序的生命周期里，他一直存在，所以不释放也没关系的，建议开始用arc，我也才开始用没多久，感觉比之前的写代码爽多了  Ａ2：记得我还是个懵懂少年的时候查过这个问题... SOF 告诉我 singleton 不需要 release... 这件事告诉我们, 要善用
单例模式的使用总结
热门推荐
张彦峰的博客
04-21 169万+
单例模式是指确保一个类在任何情况下都绝对只有一个实例，并提供一个全局访问点。实现方式介绍分析：饿汉式单例模式+懒汉式单例模式（双重检查锁）+静态内部类实现单例模式+注册式单例模式
【C++】C++ 单例模式总结（5种单例实现方法）
unonoi的博客
11-04 7万+
C++ 单例模式的几种实现方式。
JAVA设计模式之单例模式
一个本科小生的奋斗史
04-16 98万+
本文继续介绍23种设计模式系列之单例模式。 概念： 　　java中单例模式是一种常见的设计模式，单例模式的写法有好几种，这里主要介绍三种：懒汉式单例、饿汉式单例、登记式单例。 　　单例模式有以下特点： 　　1、单例类只能有一个实例。 　　2、单例类必须自己创建自己的唯一实例。 　　3、单例类必须给所有其他对象提供这一实例。　　单例模式确保某个类只有一个实例，而且自行实例化并向整个系统提供这个实例...
单例模式介绍
12-15
android 六种单例模式源码介绍，反序列化解决方案，编译环境为android studio 3.0.1
使用单例模式创建学生管理系统（饿汉式、懒汉式）
04-28
使用单例模式创建学生管理系统（饿汉式、懒汉式）
C#单例模式
09-09
C#单例模式的应用，这里给的是C#里面一个单例模式的应用案例，面向对象过程中不可避免的需要用到单例模式，我在博客园中有详细说明单例模式怎么应用的，链接地址：...
.Net 单例模式(Singleton)
01-02
 单例模式 Singleton Pattern 问题解决： （1）单例模式简介： Singleton模式要求一个类有且仅有一个实例，并且提供了一个全局的访问点。这就提出了一个问题：如何绕过常规的构造器，提供一种机制来保证一个类只有...
设计模式（十）：装饰者模式
wenqi1992的博客
04-29 434
装饰者模式的介绍
C++11 设计模式6. 建造者模式，也叫做生成器模式
hunandede的博客
04-29 692
建造者模式（也被成为⽣成器模式），是⼀种创建型设计模式，软件开发过程中有的时候需要创建很复杂的对象，⽽建造者模式的主要思想是将对象的构建过程分为多个步骤，并为每个步骤定义⼀个抽象的接⼝。，构建过程相对复杂，⽽我们使⽤建造者模式将计算机的构建过程封装在⼀个具体的建造者类中，⽽指导者类则负责指导构建的步骤和顺序。每个具体的建造者类可以负责构建不同型号或配置的计算机，客户端代码可以通过选择不同的建造者来创建不同类型的计算机，这样就可以根据需要构建不同表示的复杂对象，更加灵活。
23种设计模式
weixin_72256328的博客
05-01 964
23种设计模式
c++设计模式
qq_27344469的博客
04-28 277
uniontech: 赵良云问题: 23种设计模式，你知道多少....，KL:大话数据结构、大话设计模式、人人都是产品经理，编程之美。ChinaSoft:数据结构，类模板与模板类，回调函数。加班复加班，加班何其多，事事待加班，项目成蹉跎；单一职责原则、开放封闭原则、依赖倒转原则。业务逻辑与界面分开，让它们之间的耦合度下降。面向对象思想(维护性 扩展性 复用性)Hollysys:深拷贝与浅拷贝。编程是一门技术，更加是一门艺术。这是看到的一篇博主写的文章，努力一次把事情做好。
Java 设计模式（行为型）
心若有所向往，何惧道阻且长。
04-28 1211
Java 设计模式（行为型）
设计模式的原则与分类
孟孟的博客
04-30 352
单一职责原则是接口隔离原则的基础，单一职责原则注重职责的划分，从职责角度进行类和接口的划分；迪米特法则 又叫做最少知道原则，一个类对于其他类知道得越少越好，简单来说就是只暴露方法入口，而实现细节不需要暴露给调用者。如果要修改一个功能，不是直接进行内部的代码修改，而是使用扩展的方式进行。结构型模式，更加注重类或对象的结合方式，将类或对象进行结合，形成一个更大的结构，在该结构下，不同的组件扮演不同的角色。一个类只需要负责一种职责即可，一个类发生变化的原因，必然是所负责的职责发生变化。
Java 设计模式（结构型）
心若有所向往，何惧道阻且长。
04-29 1106
Java 设计模式（结构型）
23种设计模式之建造者模式
JAVA开发区的博客
04-28 1081
将一个复杂对象的构造与它的表示分离，使同样的建造过程可以创建不同的表示，这样的设计模式被称为建造者模式。它是一个负责的对象分解为多个简单的对象，然后一步步构建而成。它将变与不变相分离，即产品的组成部分是不变的，但每一部分是可以灵活选择的。
【设计模式】17、iterator 迭代器模式
最新发布
呆呆的猫的博客
05-02 465
为了集合数据的安全性, 或方便迭代, 可以用迭代器接口. 屏蔽复杂的内部逻辑, 外部只能使用迭代器遍历

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值