zoukankan      html  css  js  c++  java

  • 浅谈C++设计模式--单例模式

    单例模式(Singleton)[分类:创建型] [目的:为程序的某个类的访问,提供唯一对象实例]

    这估计是设计模式里面最简单的一个类了,下面我们一起看看，单例它是什么?以及如何实现一个单例

    • 基本定义
      • 保证一个类仅有一个实例，并提供一个访问它的全局访问点.
    • 个人理解
      • 就是一个类在整个程序里面，有且仅有一个实例，这个实例由该类自己负责创建和保存，这样保证它不会在任何其他地方被创建，必须提供一个访问这个实例的全局访问接口.
      • 那么有些人可能有疑问，为什么不直接用一个全局变量来控制外部对它的访问呢？在这里如果用全局变量来控制外部的访问它实际上还是不能避免你实例化多个对象，这样还是达不到单例有且仅有一个实例的目的。
    • 单例的特征
      1. 有且仅有一个实例
      2. 实例必须由自己创建和保存
      3. 要提供和给外部访问实例的接口
    • UML结构图

     

    • 从UML结构图中我们可以一步步实现出以下代码
    • 简单版本的单例模式
     1 class Singleton
 2 {
 3 public:
 4     static Singleton& GetInstance() 
 5     {
 6         static Singleton instance;
 7         return  instance;
 8     }
 9 private:
10     Singleton();
11 
12 };
    • 这里我们可以看到，这个版本构造函数被私有化了，因此外部无法直接调用单例的构造器，而且使用静态的局部变量做返回，这样不需要考虑对内存的管理，是不是非常方便！但是我们在对函数执行以下操作时
    1 Singleton instance1=Singleton::GetInstance(); 
2 Singleton instance2=Singleton::GetInstance();
3 qDebug()<<"instance1 address:"<<&instance1;
4 qDebug()<<"instance2 address:"<<&instance2;
    • 我们运行程序看结果

    •  在这里instance1和instance2实例他们的地址是完全不同的.这样的做法是不可取的，不是真正的单例，那么如何避免这样的问题的？跟开发者说你们直接调用GetInstance接口就行。
    • NONONO....
    • 下面我们看看修改版本的单例看看 
     1 class SingletonModify
 2 {
 3 public:
 4     static SingletonModify& GetInstance() 
 5     {
 6         static SingletonModify instance;
 7         return  instance;
 8     }
 9     void sayHello();
10 private:
11     SingletonModify();
12     SingletonModify(SingletonModify const &);//to use this modify wrong demo
13     SingletonModify& operator =(SingletonModify const &);//to use this modify wrong demo
14 };
    • 从上面我们可以看出，我们重新定义了构造器以及=操作，这里不需要实现。然后我们再用相同的方式测试看看，这下编译器编译不通过了，那我们想调用实例的方法或者操作实例怎么办呢？
    SingletonModify::GetInstance().sayHello();//after modify code,
    • 那我们只能通过上述方法访问实例了,保证了实例的唯一性了。
    • 简单版本的单例模式技术总结
    1. 将构造器私有化(保证外部无法创建实例) 
    2. 使用静态的局部变量作为返回(无需考虑内存管理的问题)
    3. 重新定义赋值运算符以及构造器.(避免=发生拷贝操作)
    • 是不是觉得到这里单例就已经差不多啦?并不是，我们使用的是C++，但是并没有使用到C++的一个重要特征：指针
    • 首先我们针对上述简单版本的单例模式再次进行修正，我们修改单例的函数返回，用指针接收，看看下面代码
     1 class SingletonSimplify
 2 {
 3 public:
 4     SingletonSimplify();
 5     static SingletonSimplify* GetInstanceptr()//simplify method
 6     {
 7         static SingletonSimplify instance;
 8         return  &instance;
 9     }
10 };
    • 测试：
    1 SingletonSimplify* instanceSmp1=SingletonSimplify::GetInstanceptr();//another simplify singleton method
2 SingletonSimplify* instanceSmp2=SingletonSimplify::GetInstanceptr();
3 qDebug()<<"instanceSmp1 address:"<<instanceSmp1;
4 qDebug()<<"instanceSmp2 address:"<<instanceSmp2;

    •  我们可以发现，用指针接收之后2个指针都是指向同一个地址，很好，这也是一种单例的实现方式，但是这个也属于访问静态局部对象，还是没有真正意义上使用到指针.再看看下面两种方式
    1. 懒汉模式
      • 先看头文件.h代码 
        •  1 class SingletonLazyMode
 2 {
 3 public:
 4     static SingletonLazyMode* GetInstance();
 5     static void InstanceDispose();
 6     void sayHi();
 7 private:
 8     SingletonLazyMode();
 9     static SingletonLazyMode* mSingletonInstance;
10     int num=10;
11 };
      • .cpp实现 
        •  1 SingletonLazyMode *SingletonLazyMode::mSingletonInstance=NULL;
 2 SingletonLazyMode *SingletonLazyMode::GetInstance()
 3 {
 4     if(mSingletonInstance==NULL)
 5     {
 6         mSingletonInstance=new SingletonLazyMode();
 7         mSingletonInstance->num=20;
 8     }
 9     return  mSingletonInstance;
10 }
11 void SingletonLazyMode::InstanceDispose()
12 {
13     if(mSingletonInstance!=NULL)
14     {
15         delete mSingletonInstance;
16         mSingletonInstance=NULL;
17     }
18 }
19 void SingletonLazyMode::sayHi()
20 {
21     qDebug()<<"hi lazy man! Number:"<<num;
22 }
23 SingletonLazyMode::SingletonLazyMode()
24 {
25 }
    2. 饿汉模式
      • 先看头文件.h代码 
        • 1 class SingletonEagerMode
2 {
3 public:
4     static SingletonEagerMode* GetInstance();
5     static void InstanceDispose();
6 private:
7     SingletonEagerMode();
8     static SingletonEagerMode* mEagerInstance;
9 };
      • .cpp实现 
        •  1 SingletonEagerMode *SingletonEagerMode::mEagerInstance=new SingletonEagerMode();
 2 SingletonEagerMode *SingletonEagerMode::GetInstance()
 3 {
 4     return  mEagerInstance;
 5 }
 6 void SingletonEagerMode::InstanceDispose()
 7 {
 8     if(mEagerInstance!=NULL)
 9     {
10         delete mEagerInstance;
11         mEagerInstance=NULL;
12     }
13 }
14 SingletonEagerMode::SingletonEagerMode()
15 {
16
17 }
    • 测试代码 
      •  1 SingletonLazyMode* lazyinstance1=SingletonLazyMode::GetInstance();//lazy mode 懒汉模式
 2     SingletonLazyMode* lazyinstance2=SingletonLazyMode::GetInstance();
 3     lazyinstance1->sayHi();
 4     lazyinstance2->sayHi();
 5     qDebug()<<"lazyinstance1 address:"<<lazyinstance1;
 6     qDebug()<<"lazyinstance2 address:"<<lazyinstance2;
 7     SingletonLazyMode::InstanceDispose();
 8     qDebug()<<"lazyinstance1 address:"<<lazyinstance1;
 9     qDebug()<<"lazyinstance2 address:"<<lazyinstance2;
10     lazyinstance1->sayHi();
11     lazyinstance2->sayHi();
12     SingletonEagerMode* eagerinstance1=SingletonEagerMode::GetInstance();//eager mode 饿汉模式
13     SingletonEagerMode* eagerinstance2=SingletonEagerMode::GetInstance();
14     qDebug()<<"eagerinstance1 address:"<<eagerinstance1;
15     qDebug()<<"eagerinstance2 address:"<<eagerinstance2;
    • 运行效果：
      • 这里我们可以看到不管是懒汉还是饿汉模式两个实例的地址均是相同的。说明我们的单例是OK的
    • 技术总结： 
    • 下面对懒汉模式和饿汉模式经行对比分析其异同点：
      • 相同点：
        • 懒汉/饿汉模式实现结构基本类似
      • 不同点：
        • 懒汉模式初始化对象是在程序调用的时候，非线程安全，由于最终实现要加Qmutex进行枷锁处理，执行效率会相对而言要低
        • 饿汉模式是程序启动的时候就已经创建好了，浪费内存，但属于线程安全，执行效率相对懒汉而言要高
    •  问题点：
    • 细心的同学可能发现了，在上面测试过程中我调用了自己定义的Dispose接口,但是还是能再次调用lazyinstance1,lazyinstance2实例中的函数和变量???这是在MinGW编译器下执行的结果，当我将编译器换成MSVC时，显示内存已经被释放掉了
    • 下图MSVC下的执行结果

    •  参考了一篇博客也没看出什么问题：https://www.cnblogs.com/chengjundu/p/11283123.html

    • 如果有朋友知道望不吝赐教!!!!感谢。

    • 最后看看我们线程安全的懒汉实现方式

    •  .h文件

       1 class SingletonThreadSafety
 2 {
 3 public:
 4     static SingletonThreadSafety* GetInstance();
 5     static void InstanceDispose();
 6 private:
 7     SingletonThreadSafety();
 8     static SingletonThreadSafety* mSaftyInstance;
 9     static QMutex mMutex;
10 };
    • .cpp代码
    •  1 SingletonThreadSafety *SingletonThreadSafety::mSaftyInstance=NULL;
 2 QMutex SingletonThreadSafety::mMutex;
 3 SingletonThreadSafety *SingletonThreadSafety::GetInstance()
 4 {
 5     if(mSaftyInstance==NULL)
 6     {
 7         QMutexLocker locker(&mMutex);
 8         if(mSaftyInstance==NULL)
 9         {
10             mSaftyInstance=new SingletonThreadSafety();
11         }
12     }
13     return  mSaftyInstance;
14 }
15 void SingletonThreadSafety::InstanceDispose()
16 {
17     if(mSaftyInstance!=NULL)
18     {
19         delete mSaftyInstance;
20         mSaftyInstance=NULL;
21     }
22 }
23 SingletonThreadSafety::SingletonThreadSafety()
24 {
25 
26 }

      这就完美解决掉了线程安全问题，但是在获取实例对象的时候需要对Qmutex进行判断，这会损失一点点性能。

    • 以上就是对单例模式的完整概述
    • 下面进行全面的技术总结：
    • 在写单例模式的时候我们要考虑到以下几个方面：
    1. 要封闭默认的构造函数，以防止多地方创建对象
    2. 类提供一个静态的对象，用来保存该实例
    3. 提供一个公共的访问实例的接口GetInstance
    4. 考虑线程安全问题

    以上单例所有内容，如有错误请指出!!!

    参考<<大话设计模式>>一书

    附源代码:

    https://gitee.com/xiaochunlu/designer-pattern/tree/master/Singleton_Pattern

    不积跬步,无以至千里; 不积小流,无以成江海.
  • 相关阅读:
    Clipper库中文文档详解
    uboot makefile构建分析
    nvidia tk1使用记录--基本环境搭建
    学习
    es6 es7新语法
    react dva发送请求详解（转）
    antDesign表单getFieldDecorator
    react dav
    js实现截取a标签的href属性和内容
    react学习
  • 原文地址：https://www.cnblogs.com/ax0409/p/13687533.html
Copyright © 2011-2022 走看看