C++设计模式——单例模式

已于 2022-05-13 08:49:03 修改
阅读量842 收藏 3
点赞数
CC 4.0 BY-SA版权
分类专栏： S10: 23种设计模式 文章标签： c++ java
于 2020-08-16 10:16:27 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/zhiyuan2021/article/details/108032795

问题描述

现在，不管开发一个多大的系统（至少我现在的部门是这样的），都会带一个日志功能；在实际开发过程中，会专门有一个日志模块，负责写日志，由于在系统的任何地方，我们都有可能要调用日志模块中的函数，进行写日志。那么，如何构造一个日志模块的实例呢？难道，每次new一个日志模块实例，写完日志，再delete，不要告诉我你是这么干的。在C++中，可以构造一个日志模块的全局变量，那么在任何地方就都可以用了，是的，不错。但是，我所在的开发部门的C++编码规范是参照Google的编码规范的。

全局变量在项目中是能不用就不用的，它是一个定时炸弹，是一个不安全隐患，特别是在多线程程序中，会有很多的不可预测性；同时，使用全局变量，也不符合面向对象的封装原则，所以，在纯面向对象的语言Java和C#中，就没有纯粹的全局变量。那么，如何完美的解决这个日志问题，就需要引入设计模式中的单例模式。

单例模式

何为单例模式，在GOF的《设计模式：可复用面向对象软件的基础》中是这样说的：保证一个类只有一个实例，并提供一个访问它的全局访问点。首先，需要保证一个类只有一个实例；在类中，要构造一个实例，就必须调用类的构造函数，如此，为了防止在外部调用类的构造函数而构造实例，需要将构造函数的访问权限标记为protected或private；最后，需要提供要给全局访问点，就需要在类中定义一个static函数，返回在类内部唯一构造的实例。意思很明白，使用UML类图表示如下。

UML类图

代码实现

单例模式，单从UML类图上来说，就一个类，没有错综复杂的关系。但是，在实际项目中，使用代码实现时，还是需要考虑很多方面的。

实现一：

/**
**提供全局访问点:变量 类
**/

#include <iostream>

using namespace std;

class Singleton
{
public:
    static Singleton *GetInstance()
    {
            if (m_Instance == NULL )
            {
                m_Instance = new Singleton ();
            }
            return m_Instance;
    }

private:
    static Singleton *m_Instance;
    Singleton(){}
    ~Singleton(){}
};

Singleton *Singleton ::m_Instance = NULL;

int main()
{
    Singleton *sa = Singleton::GetInstance();
    Singleton *sa2 = Singleton::GetInstance();

    if(sa == sa2){
        cout << "sa===sa2" << endl;
    }

    return 0;
}

#include <iostream>
using namespace std;
 
class Singleton
{
public:
    static Singleton *GetInstance()
    {
        if (m_Instance == NULL )
        {
            m_Instance = new Singleton ();
        }
        return m_Instance;
    }
 
    static void DestoryInstance()
    {
        if (m_Instance != NULL )
        {
            delete m_Instance;
            m_Instance = NULL ;
        }
    }
 
    // This is just a operation example
    int GetTest()
    {
        return m_Test;
    }
 
private:
    Singleton(){ m_Test = 10; }
    static Singleton *m_Instance;
    int m_Test;
};
 
Singleton *Singleton ::m_Instance = NULL;
 
int main(int argc , char *argv [])
{
    Singleton *singletonObj = Singleton ::GetInstance();
    cout<<singletonObj->GetTest()<<endl;
 
    Singleton ::DestoryInstance();
    return 0;
}

这是最简单，也是最普遍的实现方式，也是现在网上各个博客中记述的实现方式，但是，这种实现方式，有很多问题，比如：没有考虑到多线程的问题，在多线程的情况下，就可能创建多个Singleton实例，以下版本是改善的版本。

实现二：

#include <iostream>
using namespace std;
 
class Singleton
{
public:
    static Singleton *GetInstance()
    {
        if (m_Instance == NULL )
        {
            Lock(); // C++没有直接的Lock操作，请使用其它库的Lock，比如Boost，此处仅为了说明
            if (m_Instance == NULL )
            {
                m_Instance = new Singleton ();
            }
            UnLock(); // C++没有直接的Lock操作，请使用其它库的Lock，比如Boost，此处仅为了说明
        }
        return m_Instance;
    }
 
    static void DestoryInstance()
    {
        if (m_Instance != NULL )
        {
            delete m_Instance;
            m_Instance = NULL ;
        }
    }
 
    int GetTest()
    {
        return m_Test;
    }
 
private:
    Singleton(){ m_Test = 0; }
    static Singleton *m_Instance;
    int m_Test;
};
 
Singleton *Singleton ::m_Instance = NULL;
 
int main(int argc , char *argv [])
{
    Singleton *singletonObj = Singleton ::GetInstance();
    cout<<singletonObj->GetTest()<<endl;
    Singleton ::DestoryInstance();
 
    return 0;
}

此处进行了两次m_Instance == NULL的判断，是借鉴了Java的单例模式实现时，使用的所谓的“双检锁”机制。因为进行一次加锁和解锁是需要付出对应的代价的，而进行两次判断，就可以避免多次加锁与解锁操作，同时也保证了线程安全。但是，这种实现方法在平时的项目开发中用的很好，也没有什么问题？但是，如果进行大数据的操作，加锁操作将成为一个性能的瓶颈；为此，一种新的单例模式的实现也就出现了。

实现三

#include <iostream>
using namespace std;
 
class Singleton
{
public:
    static Singleton *GetInstance()
    {
        return const_cast <Singleton *>(m_Instance);
    }
 
    static void DestoryInstance()
    {
        if (m_Instance != NULL )
        {
            delete m_Instance;
            m_Instance = NULL ;
        }
    }
 
    int GetTest()
    {
        return m_Test;
    }
 
private:
    Singleton(){ m_Test = 10; }
    static const Singleton *m_Instance;
    int m_Test;
};
 
const Singleton *Singleton ::m_Instance = new Singleton();
 
int main(int argc , char *argv [])
{
    Singleton *singletonObj = Singleton ::GetInstance();
    cout<<singletonObj->GetTest()<<endl;
    Singleton ::DestoryInstance();
}

因为静态初始化在程序开始时，也就是进入主函数之前，由主线程以单线程方式完成了初始化，所以静态初始化实例保证了线程安全性。在性能要求比较高时，就可以使用这种方式，从而避免频繁的加锁和解锁造成的资源浪费。由于上述三种实现，都要考虑到实例的销毁，关于实例的销毁，待会在分析。由此，就出现了第四种实现方式：

实现四

#include <iostream>
using namespace std;
 
class Singleton
{
public:
    static Singleton *GetInstance()
    {
        static Singleton m_Instance;
        return &m_Instance;
    }
 
    int GetTest()
    {
        return m_Test++;
    }
 
private:
    Singleton(){ m_Test = 10; };
    int m_Test;
};
 
int main(int argc , char *argv [])
{
    Singleton *singletonObj = Singleton ::GetInstance();
    cout<<singletonObj->GetTest()<<endl;
 
    singletonObj = Singleton ::GetInstance();
    cout<<singletonObj->GetTest()<<endl;
}

以上就是四种主流的单例模式的实现方式，如果大家还有什么好的实现方式，希望大家能推荐给我。谢谢了。

实例销毁

在上述的四种方法中，除了第四种没有使用new操作符实例化对象以外，其余三种都使用了；我们一般的编程观念是，new操作是需要和delete操作进行匹配的；是的，这种观念是正确的。在上述的实现中，是添加了一个DestoryInstance的static函数，这也是最简单，最普通的处理方法了；但是，很多时候，我们是很容易忘记调用DestoryInstance函数，就像你忘记了调用delete操作一样。由于怕忘记delete操作，所以就有了智能指针；那么，在单例模型中，没有“智能单例”，该怎么办？怎么办？

那我先从实际的项目中说起吧，在实际项目中，特别是客户端开发，其实是不在乎这个实例的销毁的。因为，全局就这么一个变量，全局都要用，它的生命周期伴随着软件的生命周期，软件结束了，它也就自然而然的结束了，因为一个程序关闭之后，它会释放它占用的内存资源的，所以，也就没有所谓的内存泄漏了。但是，有以下情况，是必须需要进行实例销毁的：

  1. 在类中，有一些文件锁了，文件句柄，数据库连接等等，这些随着程序的关闭而不会立即关闭的资源，必须要在程序关闭前，进行手动释放；
  2. 具有强迫症的程序员。

以上，就是我总结的两点。

虽然，在代码实现部分的第四种方法能满足第二个条件，但是无法满足第一个条件。好了，接下来，就介绍一种方法，这种方法也是我从网上学习而来的，代码实现如下：

#include <iostream>
using namespace std;
 
class Singleton
{
public:
    static Singleton *GetInstance()
    {
        return m_Instance;
    }
 
    int GetTest()
    {
        return m_Test;
    }
 
private:
    Singleton(){ m_Test = 10; }
    static Singleton *m_Instance;
    int m_Test;
 
    // This is important
    class GC
    {
    public :
        ~GC()
        {
            // We can destory all the resouce here, eg:db connector, file handle and so on
            if (m_Instance != NULL )
            {
                cout<< "Here is the test" <<endl;
                delete m_Instance;
                m_Instance = NULL ;
            }
        }
    };
    static GC gc;
};
 
Singleton *Singleton ::m_Instance = new Singleton();
Singleton ::GC Singleton ::gc;
 
int main(int argc , char *argv [])
{
    Singleton *singletonObj = Singleton ::GetInstance();
    cout<<singletonObj->GetTest()<<endl;
 
    return 0;
}

在程序运行结束时，系统会调用Singleton的静态成员GC的析构函数，该析构函数会进行资源的释放，而这种资源的释放方式是在程序员“不知道”的情况下进行的，而程序员不用特别的去关心，使用单例模式的代码时，不必关心资源的释放。那么这种实现方式的原理是什么呢？我剖析问题时，喜欢剖析到问题的根上去，绝不糊涂的停留在表面。由于程序在结束的时候，系统会自动析构所有的全局变量，实际上，系统也会析构所有类的静态成员变量，就像这些静态变量是全局变量一样。我们知道，静态变量和全局变量在内存中，都是存储在静态存储区的，所以在析构时，是同等对待的。

由于此处使用了一个内部GC类，而该类的作用就是用来释放资源，而这种使用技巧在C++中是广泛存在的。

模式扩展

在实际项目中，一个模式不会像我们这里的代码那样简单，只有在熟练了各种设计模式的特点，才能更好的在实际项目中进行运用。单例模式和工厂模式在实际项目中经常见到，两种模式的组合，在项目中也是很常见的。所以，有必要总结一下两种模式的结合使用。

一种产品，在一个工厂中进行生产，这是一个工厂模式的描述；而只需要一个工厂，就可以生产一种产品，这是一个单例模式的描述。所以，在实际中，一种产品，我们只需要一个工厂，此时，就需要工厂模式和单例模式的结合设计。由于单例模式提供对外一个全局的访问点，所以，我们就需要使用简单工厂模式中那样的方法，定义一个标识，用来标识要创建的是哪一个单件。由于模拟代码较多，在文章最后，提供下载链接。

总结

为了写这篇文章，自己调查了很多方面的资料，由于网上的资料在各方面都有很多的瑕疵，质量参次不齐，对我也造成了一定的误导。而这篇文章，有我自己的理解，如有错误，请大家指正。

由于该文对设计模式的总结，我认为比网上80%的都全面，希望对大家有用。在实际的开发中，并不会用到单例模式的这么多种，每一种设计模式，都应该在最适合的场合下使用，在日后的项目中，应做到有地放矢，而不能为了使用设计模式而使用设计模式。

单例+模板

#include <iostream>

using namespace std;

template<typename T>
class Singleton
{
public:
    static T *getInstance()
    {
        if(p == NULL)
        {
            p = new T();
        }
        return p;
    }
private:
    static T *p;
};

template<typename T>
T *Singleton<T>::p = nullptr;

class Log{
public:
    Log();
    ~Log();
public:
    int display()
    {
        printf("file:%s func:%s line:%d\n", __FILE__, __FUNCTION__, __LINE__);
        return 0;
    }
};

class Global
{
public:
    Log *mplog;
};

int main()
{
    printf("file:%s func:%s line:%d\n", __FILE__, __FUNCTION__, __LINE__);
    Log *test1;
    Log *test2;

    test1 = Singleton<Global>::getInstance()->mplog; //实例化对象赋值
    test2 = Singleton<Global>::getInstance()->mplog; //实例化对象赋值

    test1->display();
    test2->display();

    printf("file:%s func:%s line:%d\n", __FILE__, __FUNCTION__, __LINE__);

    if(test1 == test2)
    {
      cout << "sa===sa2" << endl;
    }

    return 0;
}

# 饿汉和饥汉

简述

单例模式（Singleton Pattern）是设计模式中最简单的形式之一，其目的是使得类的一个对象成为系统中的唯一实例。

这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一对象的方式，可以直接访问，不需要实例化该类的对象。

UML 结构图

Singleton Pattern

要点

单例模式的要点有三个：

  • 单例类有且仅有一个实例
  • 单例类必须自行创建自己的唯一实例
  • 单例类必须给所有其他对象提供这一实例

从具体实现角度来说，可分为以下三点：

  • 提供一个 private 构造函数（防止外部调用而构造类的实例）
  • 提供一个该类的 static private 对象
  • 提供一个 static public 函数，用于创建或获取其本身的静态私有对象（例如：GetInstance()）

除此之外，还有一些关键点（需要多加注意，很容易忽视）：

  • 线程安全（双检锁 - DCL，即：double-checked locking）
  • 资源释放


局部静态变量

这种方式很常见，实现非常简单，而且无需担心单例的销毁问题。

// singleton.h
#ifndef SINGLETON_H
#define SINGLETON_H

// 非真正意义上的单例
class Singleton
{
public:
    static Singleton& GetInstance()
    {
        static Singleton instance;
        return instance;
    }

private:
    Singleton() {}
};

#endif // SINGLETON_H

但是，这并非真正意义上的单例。当使用如下方式访问单例时：

Singleton single = Singleton::GetInstance();

这会出现了一个类拷贝问题，从而违背了单例的特性。产生这个问题原因在于：编译器会生成一个默认的拷贝构造函数，来支持类的拷贝。

为了避免这个问题，有两种解决方式：

  1. 将 GetInstance() 函数的返回类型修改为指针，而非引用。
  2. 显式地声明类的拷贝构造函数，并重载赋值运算符。

对于第一种方式，只需要修改 GetInstance() 的返回类型即可：

// singleton.h
#ifndef SINGLETON_H
#define SINGLETON_H

// 单例
class Singleton
{
public:
    // 修改返回类型为指针类型
    static Singleton* GetInstance()
    {
        static Singleton instance;
        return &instance;
    }

private:
    Singleton() {}
};

#endif // SINGLETON_H

既然编译器会生成一个默认的拷贝构造函数，那么，为什么不让编译器不这么干呢？这就产生了第二种方式：

// singleton.h
#ifndef SINGLETON_H
#define SINGLETON_H

#include <iostream>

using namespace std;

// 单例
class Singleton
{
public:
    static Singleton& GetInstance()
    {
        static Singleton instance;
        return instance;
    }

    void doSomething() {
        cout << "Do something" << endl;
    }

private:
    Singleton() {}  // 构造函数（被保护）
    Singleton(Singleton const &);  // 无需实现
    Singleton& operator = (const Singleton &);  // 无需实现
};

#endif // SINGLETON_H

这样以来，既可以保证只存在一个实例，又不用考虑内存回收的问题。

Singleton::GetInstance().doSomething();  // OK
Singleton single = Singleton::GetInstance();  // Error 不能编译通过
  • 汉式/饿汉式

在讲解之前，先看看 Singleton 的头文件（懒汉式/饿汉式公用）：

// singleton.h
#ifndef SINGLETON_H
#define SINGLETON_H

// 单例 - 懒汉式/饿汉式公用
class Singleton
{
public:
    static Singleton* GetInstance();

private:
    Singleton() {}  // 构造函数（被保护）

private:
    static Singleton *m_pSingleton;  // 指向单例对象的指针
};

#endif // SINGLETON_H

懒汉式的特点：

  • Lazy 初始化
  • 非多线程安全

优点：第一次调用才初始化，避免内存浪费。
缺点：必须加锁（在“线程安全”部分分享如何加锁）才能保证单例，但加锁会影响效率。

// singleton.cpp
#include "singleton.h"

// 单例 - 懒汉式
Singleton *Singleton::m_pSingleton = NULL;

Singleton *Singleton::GetInstance()
{
    if (m_pSingleton == NULL)
        m_pSingleton = new Singleton();

    return m_pSingleton;
}

饿汉式的特点：

  • 非 Lazy 初始化
  • 多线程安全

优点：没有加锁，执行效率会提高。
缺点：类加载时就初始化，浪费内存。

// singleton.cpp
#include "singleton.h"

// 单例 - 饿汉式
Singleton *Singleton::m_pSingleton = new Singleton();

Singleton *Singleton::GetInstance()
{
    return m_pSingleton;
}


线程安全

在懒汉式下，如果使用多线程，会出现线程安全隐患。为了解决这个问题，可以引入双检锁 - DCL 机制。

// singleton.h
#ifndef SINGLETON_H
#define SINGLETON_H

#include <iostream>
#include <mutex>
using namespace std;

// 单例 - 懒汉式/饿汉式公用
class Singleton
{
public:
    static Singleton* GetInstance();

private:
    Singleton() {}  // 构造函数（被保护）

private:
    static Singleton *m_pSingleton;  // 指向单例对象的指针
    static mutex m_mutex;  // 锁
};

#endif // SINGLETON_H
// singleton.cpp
#include "singleton.h"

// 单例 - 懒汉式（双检锁 DCL 机制）
Singleton *Singleton::m_pSingleton = NULL;
mutex Singleton::m_mutex;

Singleton *Singleton::GetInstance()
{
    if (m_pSingleton == NULL) {
        std::lock_guard<std::mutex> lock(m_mutex);  // 自解锁
        if (m_pSingleton == NULL) {
            m_pSingleton = new Singleton();
        }
    }
    return m_pSingleton;
}

这样，就可以保证线程安全了，但是，会带来较小的性能影响。


资源释放

有内存申请，就要有对应的释放，可以采用下述两种方式：

  • 主动释放（手动调用接口来释放资源）
  • 自动释放（由程序自己释放）

要手动释放资源，添加一个 static 接口，编写需要释放资源的代码：

// 单例 - 主动释放
static void DestoryInstance()
{
    if (m_pSingleton != NULL) {
        delete m_pSingleton;
        m_pSingleton = NULL;
    }
}

然后在需要释放的时候，手动调用该接口：

Singleton::GetInstance()->DestoryInstance();

方式虽然简单，但很多时候，容易忘记调用 DestoryInstance()。这时，可以采用更方便的方式：

// singleton.h
#ifndef SINGLETON_H
#define SINGLETON_H

#include <iostream>

using namespace std;

// 单例 - 自动释放
class Singleton
{
public:
    static Singleton* GetInstance();

private:
    Singleton() {}  // 构造函数（被保护）

private:
    static Singleton *m_pSingleton;  // 指向单例对象的指针

    // GC 机制
    class GC
    {
    public:
        ~GC()
        {
            // 可以在这里销毁所有的资源，例如：db 连接、文件句柄等
            if (m_pSingleton != NULL) {
                cout << "Here destroy the m_pSingleton..." << endl;
                delete m_pSingleton;
                m_pSingleton = NULL;
            }
        }
        static GC gc;  // 用于释放单例
    };
};

#endif // SINGLETON_H

只需要声明 Singleton::GC 即可：

// main.cpp
#include "singleton.h"

Singleton::GC Singleton::GC::gc; // 重要

int main()
{
    Singleton *pSingleton1 = Singleton::GetInstance();
    Singleton *pSingleton2 = Singleton::GetInstance();

    cout << (pSingleton1 == pSingleton2) << endl;

    return 0;
}

在程序运行结束时，系统会调用 Singleton 的静态成员 GC 的析构函数，该析构函数会进行资源的释放。这种方式的最大优点就是在“不知不觉”中进行，所以，对我们来说，尤为省心。

鸿蒙OS单例模式 

miscservices_time

https://gitee.com/openharmony/miscservices_time/blob/master/services/src/time_service.cpp

sptr<TimeService> TimeService::GetInstance()
{
    if (instance_ == nullptr) {
        std::lock_guard<std::mutex> autoLock(instanceLock_);
        if (instance_ == nullptr) {
            instance_ = new TimeService;
        }
    }
    return instance_;
}

C++设计模式——Singleton单例模式
程序员与背包客_CoderZ
11-24 1333
单例模式，英文全称，是一种创建型设计模式，它保证一个类在程序中仅有一个实例，并对外提供一个访问的该类实例的全局接口。单例模式通常用于需要控制对象资源的开发场景，一个类只创建一个对象的设计，既可以避免创建过多副本所造成的资源浪费现象，又可以避免引发数据一致性等问题。在数据库连接、线程池设计、日志系统设计等开发场景，经常使用单例模式来创建对象，可以有效地降低对内存资源的占用。在编码时，为了防止外部直接通过new关键字创建对象实例，Singleton类的构造函数必须是私有的。
【设计模式】——单例模式（Singleton Pattern）
J^T的博客
08-05 4250
单例模式（Singleton Pattern）是这些设计模式中的一种，它提供了一种创建对象的最佳方式，确保一个类只有一个实例，并提供一个全局访问点来获取这个实例。这种模式在需要严格控制资源访问、管理全局状态或实现共享资源访问时非常有用。
C++单例模式与工厂模式
qq_42987967的博客
07-31 1417
工厂模式中对象的创建过程是我们不需要去关心的，而我们注重的是对象的实际操作，所以，我们需要分离对象的创建和操作两部分，如此，方便后期的程序扩展和维护。在这懒汉式用的是静态局部变量的方法，充分使用了静态局部变量的特点。C#当中弱化了全局变量的声明与定义的概念，用C#写单例也相对简单的多。抽象产品类、具体产品类、抽象工厂类、具体工厂类。抽象产品类、具体产品类、抽象工厂类、具体工厂类。抽象产品类、具体产品类、一个简单工厂类。一个具体的工厂可以生产多个具体产品。每个具体工厂只能生产一种具体的产品。...
C++的单例模式
最新发布
abssg的博客
06-24 547
为了只实例化出一个对象，会将默认构造函数私有，将拷贝构造函删除，由于实例出是的同一个对象，当这个对象被多个线程使用(线程安全问题)或多个模板类使用(重复调用析构函数)，需要将析构函数私有，并需要锁进行安全保护，我们需要在public下写能够调用默认构造函数(只调用一次)和析构函数的两个自定义函数。2.更重要的原因：单例模式的对象是自引用，就是我包含我自己，我自己就是我的成员，发生delete时，如果成员有自定义类型，要调用成员的析构函数，而单例对象的成员就是自己，导致无线死循环。分为懒汉模式和饿汉模式。
7、【C++】单例模式/工厂模式
阿牧路泽
11-03 2032
单例模式、工厂模式
c++设计模式之单例模式
weixin_42129433的博客
12-05 782
介绍单例模式的用途及用法
C++单例
linalg的博客
03-14 5675
C++单例中也存在线程安全问题，这篇文章总结单例模式的各种创建方式，讨论利弊。单例的目的是为实现结构对象中只有一个实例，对于类的构造函数，拷贝构造函数、赋值构造函数应当做对应处理。普通构造函数和析构函数 应为private 级别，拷贝构造函数和赋值构造函数应当删除，防止构造多个对象。以下分析懒汉式、饿汉式、call_once 等构造方式及利弊分析。 1. 懒汉式 //MyClass.h class MyClass{ public: static MyClass* get...
C++设计模式——单例模式-附件资源
03-05
C++设计模式——单例模式-附件资源
C++设计模式——单例模式（Singleton 模式）
赵小厨的博客
10-05 1061
单例模式 解决什么问题？ 保证一个类仅有一个实例，并提供一个访问它的全局访问点，例如数据库创建等，通常此类对象只需要实例化一次 如何实现？ 将构造函数声明为私有的或者保护的，不让外部直接创建该对象 提供一个静态指针和静态方法，提供全局的访问点 分类 1.懒汉模式： 在程序运行时，调用到该对象再创建该对象。 加载类时比较快，但运行时获取对象的速度比较慢；线程不安全。 无论是饿汉还是懒汉模...
C++单例模式终极指南，深度解析不同应用场景，学单例这一篇就够了
在下马农的碎碎念
09-27 781
C++单例模式代码 单例模式应用场景 C#单例模式 线程安全的单例模式 工厂模式和单例模式 单例模式懒汉和饿汉C++ 双重检查锁单例模式 单例模式c 单例模式双重检查锁 C++单例模式设计 单例模式java 单例模式的好处 单例类 单例对象 单例模式 python
4创建型模式之单例模式__多线程下的懒汉式单例和饿汉式单例
weixin_30314813的博客
02-09 232
//1"懒汉"模式虽然有优点，但是每次调用GetInstance()静态方法时，必须判断 // NULL == m_instance，使程序相对开销增大。 //2多线程中会导致多个实例的产生，从而导致运行代码不正确以及内存的泄露。 //3提供释放资源的函数 讨论: 这是因为C++中构造函数并不是线...
C++设计模式(一)单例模式
月下小溪
08-04 6814
C++单例模式也称为单件模式、单子模式。使用单例模式，保证一个类仅有一个实例，并提供一个访问它的全局访问点，该实例被所有程序模块共享。有很多地方需要这样的功能模块，如系统的日志输出等。 单例模式有许多种实现方法， a. 懒汉式：使用的时候才创建，多线程访问的时候线程不安全(双检锁) b. 饿汉式：类文件加载的时候已经创建好了对象，如果对象一直没有使用，则类对象浪费空间 特点与选择： 如果要进...
C++常用设计模式1——单例模式
凛冬烈焰的博客
06-13 461
最近在学习各种设计模式，感觉收获非常多。首先推荐一个视频：https://www.bilibili.com/video/av22292899，不太清楚原版的课程在哪里。这个课的老师讲得非常透彻，听完后有种醍醐灌顶之感。我们知道，C++是一种支持面向对象编程的语言。所谓“面向对象”的三大特性，相信大家都已经滚瓜烂熟：封装、继承、多态。但很多人在实际编程过程中，只是知道皮毛而不是领会“面向对象”的精髓...
单实例设计模式和常量数据成员，常量成员函数，常对象是什么
m0_65334415的博客
04-16 991
单实例设计模式 一：什么是设计模式 套路，解决问题的惯用方法，不同语言实现的方式不一样，但是思想是一样的，目前公认的设计模式有23种 二：什么是单实例设计模式 设计模式之一，保证系统中应用这个模式类只有一个实例对象，也就是通过这个单实例设计模式写一个C++的类，然后用这种方法写出的类 永远只有一个实例化对象，在程序中，最多只能存一个实例对象，最少可以没有实例化对象，就算用这个类去创建对象，也只能创建一个对象 使用c++实现单例模式 想办法让类只能创建一个对象（思路：直接弄行不通，可以试
C++多线程共享资源加锁
Wangzhyy的博客
11-23 5660
线程同步是多线程程序设计的核心内容，它的目的是正确处理多线程并发时的各种问题，例如线程的等待、多个线程访问同一数据时的互斥，防死锁等。Win32提供多种内核对象和手段用于线程同步，如互斥量、信号量、事件、临界区等。所不同的是，互斥量、信号量、事件都是 Windows的内核对象，当程序对这些对象进行控制时会自动转换到核心态，而临界区本身不是内核对象，它是工作在用户态的。我们知道从用户态转换到核心态是
面向小白的C++学习笔记 Part2
m0_47537507的博客
06-12 148
Part2 开始进入程序设计吧 强迫症妄图保持和上一篇文章格式一致…但是失败了，看来并不能首行缩进，过一阵子把第一篇文章的格式改一改吧… 那么就愉快的进入后面的学习吧（一点都不愉快！） ...
C/C++中的static关键字详解
qq_30024069的博客
04-25 207
注：此篇博客取自https://www.cnblogs.com/qintangtao/p/3285937.html，原谅我的强迫症重新整理一下。 static有两种用法：面向过程程序设计中的static和面向对象程序设计中的static。前者应用于普通变量和函数，不涉及类；后者主要说明static在类中的作用。 在C中仅涉及到面向过程程序设计，C++中有面向过程和面向对象。 一.面向过程程序设...
C++设计模式之单例模式详解（懒汉模式、饿汉模式、双重锁）
热门推荐
trackxiaoxin321的博客
12-06 1万+
有时，我们希望类的实例对象有且仅有一个，比如某个页面，我们希望它如果出现，永远只有一个，那么此时你可能就需要用到单例模式了。（PS：本人亲身经历过手写单例模式的面试，所以以下代码必须能够手撕！！！） 单例模式：保证一个类仅有一个实例，并提供一个访问它的全局访问点。首先，怎么让类只有一个实例呢？肯定是构造函数需要做点“手脚”了，如果构造函数一如既往的是public属性，那还是可以任意构造对象，则不满足要求了。所以大神们想出来将构造函数私有化的方法，即把构造函数设置成私有属性，并对外提供一...
C++设计模式源代码库完整解析
文件标题为"设计模式源代码"，描述中列举了多种设计模式的名称，而标签则明确指出了设计模式和使用的编程语言——C++。虽然压缩包子文件名称仅提供了"设计模式源代码"，但我们可以从标题和描述中推断出具体的文件...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

静思心远

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值