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;}static void DestoryInstance(){if (m_Instance != NULL ){delete m_Instance;m_Instance = NULL ;}}// This is just a operation exampleint 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 importantclass GC{public :~GC(){// We can destory all the resouce here, eg:db connector, file handle and so onif (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++代码编辑时应该能够把.h和.cpp文件分开编辑是最好的，也就是把接口和实现分开编辑，便于代码的修改和完善。

简单的练习：

//Singleton.h#pragma once#include <iostream>using namespace std;class Singleton{public:static Singleton* GetInstance(const char* name);virtual void Show() {}protected: //必须为保护，如果是私有属性，子类无法访问父类的构造函数Singleton() {}private:static Singleton *singleton; //唯一实例的指针};//Singleton.cpp#include "Singleton.h"#include "SingletonA.h"#include "SingletonB.h"Singleton* Singleton::singleton = NULL;Singleton* Singleton::GetInstance(const char* name){if (singleton == NULL){if (strcmp(name, "SingletonA") == 0)singleton = new SingletonA();else if (strcmp(name, "SingletonB") == 0)singleton = new SingletonB();elsesingleton = new Singleton();}return singleton;}//SingletonA.h#pragma once#include "Singleton.h"class SingletonA : public Singleton{friend class Singleton; //必须为友元类，否则父类无法访问子类的构造函数public:void Show() { cout << "SingletonA" << endl; }private:   //为保护属性，这样外界无法通过构造函数进行实例化SingletonA() {}};//SingletonB.h#pragma once#include "Singleton.h"class SingletonB : public Singleton{friend class Singleton; //必须为友元类，否则父类无法访问子类的构造函数public:void Show(){ cout << "SingletonB" << endl; }private:  //为保护属性，这样外界无法通过构造函数进行实例化SingletonB() {}};#include "Singleton.h"int main(){Singleton *st = Singleton::GetInstance("SingletonA");st->Show();return 0;}