C++单件模式的实现

单件模式：其实就是保证了一个类有且仅有一个对像，又提供一个全局访问方法。对某些类来说，希望它只有一个对像，那么用单件模式设计再好不过了。很多人在刚开始时不知道Ogre中getSingleton()、getSingletonPtr（）是什么意思（我刚开始也不懂），其实它就是用了单件模式，用来获取实例指针。比如Ogre中的MeshManager、SceneManager等都使用了单件模式。

如何实现：简单来说，就是在类中添加一个返回类对像的方法（不存在对像则创建或用“new”来创建）。我的做

                  法是不用"new"来创建（把构造函数设为私有或保护类型），而在getSingletonPtr（）中进行创建。

使用宏定义： 为了减少代码的重复量，适应更多的类，可以使用宏定义来实现。

                   例：//************单件模式的声明**************
                          #define DECLARE_SINGLETON(T)\
                                       protected:\
                                       static T* handleT;\             //用于保存对像的指针
                                       static void deleteT();\        //删除对像函数
                                       T(){}\                                 //保护类型的构造函数，防止直接实例化
                                       public:\
                                        ~T(){deleteT();}\
                                        static T* getSingletonPtr();\            //返回唯一对像的指针

                          //************单件模式的实现**************
                          #define IMPLEMENT_SINGLETON(T)\
                                       T* T::handleT(NULL);\
                                       T* T::getSingletonPtr()\
                                       {\
                                              if(!handleT)\                              //如不存在对像则创建，否则直接返回对像指针
                                              {\
                                                     handleT = new T;\
                                               }\
                                               return handleT;\
                                       }\
                                       void T::deleteT()\                              //删除唯一对像
                                       {\
                                               if(handleT)\
                                               {\
                                                      delete handleT;\
                                               }\
                                       }

上面的代码可以放在头文件中（比如StdAfx.h文件），然后在要实现单件模式的类的.h声明文件中使用

DECLARE_SINGLETON(类名)；在类的.cpp实现文件中使用IMPLEMENT_SINGLETON(类名)。                       

注：如果你是直接COPY上面的代码，在使用时应当把注释全部去掉，否则会编译出错（因为宏定义...）。

 

使用模版实现：使用模版类实现也是一个不错的方法，Ogre中的单件模式就是用模版类来实现的！！   

                          下面是Ogre中Singleton模版类的源代码：

                          template <typename T>
                          class Singleton
                          {
                             protected:
                                 static T* ms_Singleton;                //用于保存实例指针
                             public:
                                 Singleton( void )                          //初始化函数
                                {
                                   assert( !ms_Singleton );
                                   // 下面是判断VC++编译器版本，版本不同相应的处理也不同
                                   #if defined( _MSC_VER ) && _MSC_VER < 1200  
                                       int offset = (int)(T*)1 - (int)(Singleton <T>*)(T*)1;
                                       ms_Singleton = (T*)((int)this + offset);
                                   #else
                                       ms_Singleton = static_cast< T* >( this );
                                   #endif
                                }
                                ~Singleton( void )                         //析构函数
                                {  
                                   assert( ms_Singleton );
                                   ms_Singleton = 0; 
                                }
                               static T& getSingleton( void )         //返回实例
                               { 
                                   assert( ms_Singleton );
                                   return ( *ms_Singleton ); 
                               }
                              static T* getSingletonPtr( void )       //返回实例指针
                              { 
                                  return ms_Singleton; 
                              }
                      };

这个类怎么用呢？  这里假设我们的一个类"CMyClass"要使用单件模式，那么我们可以这样做：

MyClass.h:

class CMyClass : public Singleton<CMyClass >

{

    CMyClass() {}   //构造函数

    ~CMyClass() {} //析构函数，这里需要自己对实例进行释放

}

MyClass.cpp:

template<> CMyClass* Ogre::Singleton<CMyClass>::ms_Singleton = NULL;

这样CMyClass 就继承了Singleton类中的方法，就可以直接用getSingleton()和getSingletonPtr()获取实例了。