C++完美实现Singleton模式 
Singleton模式是常用的设计模式之一，但是要实现一个真正实用的设计模式却也不是件容易的事情。

1.         标准的实现

class Singleton

{

public:

       static Singleton * Instance()

       {

              if( 0== _instance)

              {

                     _instance = new Singleton;

              }

              return _instance;

       }

protected:

       Singleton(void)

       {

       }

       virtual ~Singleton(void)

       {

       }

       static Singleton* _instance;

};

       这是教科书上使用的方法。看起来没有什么问题，其实包含很多的问题。下面我们一个一个的解决。

2.         自动垃圾回收

上面的程序必须记住在程序结束的时候，释放内存。为了让它自动的释放内存，我们引入auto_ptr改变它。

#include <memory>

#include <iostream>using namespace std;

class Singleton

{

public:

       static Singleton * Instance()

       {

              if( 0== _instance.get())

              {

                     _instance.reset( new Singleton);

              }

              return _instance.get();

       }

protected:

       Singleton(void)

       {

              cout <<"Create Singleton"<<endl;

       }

       virtual ~Singleton(void)

       {

              cout << "Destroy Singleton"<<endl;

       }

       friend class auto_ptr<Singleton>;

       static auto_ptr<Singleton> _instance;

};

//Singleton.cpp
auto_ptr<Singleton> Singleton::_instance;

3.         增加模板

在我的一个工程中，有多个的Singleton类，对Singleton类，我都要实现上面这一切，这让我觉得烦死了。于是我想到了模板来完成这些重复的工作。

现在我们要添加本文中最吸引人单件实现：

/********************************************************************

    (c) 2003-2005 C2217 Studio

    Module:    Singleton.h

    Author:     Yangjun D.

    Created:    9/3/2005   23:17

    Purpose:    Implement singleton pattern

    History:

*********************************************************************/#pragma once

 

#include <memory>using namespace std;

using namespace C2217::Win32;

 

namespace C2217

{

namespace Pattern 

{

template <class T>class Singleton

{

public:

       static inline T* instance();

       

private:

       Singleton(void){}

       ~Singleton(void){}

       Singleton(const Singleton&){}

       Singleton & operator= (const Singleton &){}

 

       static auto_ptr<T> _instance;

};

 

template <class T>

auto_ptr<T> Singleton<T>::_instance;

 

template <class T>

 inline T* Singleton<T>::instance()

{

       if( 0== _instance.get())

       {

              _instance.reset ( new T);

       }

       

       return _instance.get();

}

 

//Class that will implement the singleton mode, 

//must use the macro in it's delare file#define DECLARE_SINGLETON_CLASS( type ) \

       friend class auto_ptr< type >;\

       friend class Singleton< type >;

}

}

 

4.         线程安全

上面的程序可以适应单线程的程序。但是如果把它用到多线程的程序就会发生问题。主要的问题在于同时执行_instance.reset ( new T); 就会同时产生两个新的对象，然后马上释放一个，这跟Singleton模式的本意不符。所以，你需要更加安全的版本：

/********************************************************************

    (c) 2003-2005 C2217 Studio

    Module:    Singleton.h

    Author:     Yangjun D.

    Created:    9/3/2005   23:17

    Purpose:    Implement singleton pattern

    History:

*********************************************************************/#pragma once

 

#include <memory>using namespace std;

#include "Interlocked.h"using namespace C2217::Win32;

 

namespace C2217

{

namespace Pattern 

{

template <class T>class Singleton

{

public:

       static inline T* instance();

       

private:

       Singleton(void){}

       ~Singleton(void){}

       Singleton(const Singleton&){}

       Singleton & operator= (const Singleton &){}

 

       static auto_ptr<T> _instance;

       static CResGuard _rs; 

};

 

template <class T>

auto_ptr<T> Singleton<T>::_instance;

 

template <class T>

CResGuard Singleton<T>::_rs; 

 

template <class T>

 inline T* Singleton<T>::instance()

{

       if( 0 == _instance.get() )

       {

              CResGuard::CGuard gd(_rs);

              if( 0== _instance.get())

              {

                     _instance.reset ( new T);

              }

       }

       return _instance.get();

}

 

//Class that will implement the singleton mode, 

//must use the macro in it's delare file#define DECLARE_SINGLETON_CLASS( type ) \

       friend class auto_ptr< type >;\

       friend class Singleton< type >;

}

}

       CresGuard 类主要的功能是线程访问同步,代码如下：

/******************************************************************************

Module:  Interlocked.h

Notices: Copyright (c) 2000 Jeffrey Richter

******************************************************************************/

 

 

#pragma once///////////////////////////////////////////////////////////////////////////////
 

// Instances of this class will be accessed by multiple threads. So, 

// all members of this class (except the constructor and destructor) 

// must be thread-safe.class CResGuard {

public:

   CResGuard()  { m_lGrdCnt = 0; InitializeCriticalSection(&m_cs); }

   ~CResGuard() { DeleteCriticalSection(&m_cs); }

 

   // IsGuarded is used for debugging
   BOOL IsGuarded() const { return(m_lGrdCnt > 0); }

 

public:

   class CGuard {

   public:

      CGuard(CResGuard& rg) : m_rg(rg) { m_rg.Guard(); };

      ~CGuard() { m_rg.Unguard(); }

 

   private:

      CResGuard& m_rg;

   };

 

private:

   void Guard()   { EnterCriticalSection(&m_cs); m_lGrdCnt++; }

   void Unguard() { m_lGrdCnt--; LeaveCriticalSection(&m_cs); }

 

   // Guard/Unguard can only be accessed by the nested CGuard class.
   friend class CResGuard::CGuard;

 

private:

   CRITICAL_SECTION m_cs;

   long m_lGrdCnt;   // # of EnterCriticalSection calls
};

 

 

///////////////////////////////////////////////////////////////////////////////5.         实用方法

比如你有一个需要实现单件模式的类，就应该这样实现：

#pragma once

#include "singleton.h"using namespace C2217::Pattern;

 

class ServiceManger

{

public:

       void Run()

       {

       }

private:

       ServiceManger(void)

       {

       }

       virtual ~ServiceManger(void)

       {

       }

       DECLARE_SINGLETON_CLASS(ServiceManger);

};

 

typedef Singleton<ServiceManger> SSManger;

 

在使用的时候很简单，跟一般的Singleton实现的方法没有什么不同。

int _tmain(int argc, _TCHAR* argv[])

{

        SSManger::instance()->Run();

}

 

一个简单的Singleton模式的实现，可以看到C++语言背后隐藏的丰富的语意，我希望有人能实现一个更好的Singleton让大家学习。我从一开始实现Singleton类的过程，其实就是我学习C++的过程，越是深入越觉得C++了不起。

 

#include <iostream>
#include <stdarg.h>// 工厂类，生产单件template<class T>class Factory{
    static T* p_;
public:
    Factory() : p_(0){}
    static T& GetSingleObject(int i = 0, ...);
};

// 初始化单件无绑定对象template<class T>
T* Factory<T>::p_ = 0;

// 获得默认构造的单件，若单件已构造，则不会改变其内容template<class T>
T& Factory<T>::GetSingleObject(int i, ...)
{
    if (!p_)
    {
        p_ = new T();
    }
    return *p_;
}

// 测试对象，必须将Factory::GetSingleObject(int i, ...)声明为友元class Single{
    int value_;

    friend Single& Factory<Single>::GetSingleObject(int i, ...);
    explicit Single(int i = 0) : value_(i){}

public:
    operator int() const
    {
        return value_;
    }
};

// 特化测试类型的工厂的获得单件函数，第一个参数作为选择测试类型的构造函数的重载选项
// 0为默认构造，1为整型实参构造，等等
// 若单件已构造，则不会改变其内容 template<> Single& Factory<Single>::GetSingleObject(int i, ...)
{
    va_list ar;
    va_start(ar, i);
    if (!p_)
    {
        switch (i)
        {
        case 0:
            p_ = new Single();
            break;
        case 1:
            p_ = new Single(va_arg(ar, int));
        }
    }
    return *p_;
}

// 测试入口int main()
{
    // 使用Single的带整型实参的构造函数获得单件Single对象。    Single& test = Factory<Single>::GetSingleObject(1, 2);
    std::cout<<test<<std::endl;
    system("pause");
    return 0;
}