这是一篇论文，文章比较长，感兴趣的可以只看其中的部分内容。

＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝


摘  要 本文提出了三种Singleton模式的实现方式，并做了对比分析。
关键字 设计模式，Singleton
    Singleton（单件）模式是一种很常用的设计模式。《Design Patterns》对它作的定义为：Ensure a class only has one instance, and provide a global point of access to it. 也就是说单件类在整个应用程序的生命周期中只能有一个实例存在，使用者通过一个全局的访问点来访问该实例。这是Singleton的两个最基本的特征，也是在实现的时候首先应该考虑的。Singleton的应用很广，它可以典型的被用来表示那些本性上具有唯一特性的系统组件，如数据库访问组件等。这一点在《Design Patterns》上有详细说明，在此就不细说了。

实现Singleton有很多途径，但都离不开两条最基本的原则。首先，要使得Singleton只有一个全局唯一的实例，我们通常的做法是将它的构造函数和拷贝构造函数私有化。再者，Singleton的全局唯一实例通常是一个static变量，这一点利用了语言的内在优势。本文给出的几种实现都比较简单，容易理解。在通常的情况下，它们足以满足要求。但缺点也是不可避免，以下我们逐一分析。

一、基于模板函数的实现

先看实现代码：

class MySingleton1

{

private:

    MySingleton1(){ cout << _T("Construct MySingleton1") << endl; }

    MySingleton1(const MySingleton1&){} //拷贝构造函数

MySingleton1 & operator =(const MySingleton1&){} //赋值函数

    template <typename T>

    friend T& GetInstanceRef();



public:

    ~MySingleton1(){ cout << _T("Destroy MySingleton1") << endl; }



public:

    void DoSomething(){ cout << _T("Do something here in MySingleton1") << endl; }

};

template <typename T>

T& GetInstanceRef() //返回全局唯一对象的一个引用

{

    static T _instance;

    return _instance;

}

template <typename T>

T* GetInstancePtr() //返回全局唯一对象的指针

{

    return &GetInstanceRef<T>();

}

上面的代码中，MySingleton1是需要单实例化的类。下面的模板函数template <typename T> T& GetInstanceRef()返回该类的唯一实例（静态变量_instance）的一个引用，另一个模板函数调用它返回该实例的指针。我们可以注意到以下几点：

1．    MySingleton1的构造函数私有，防止了程序员随意构造它的实例。

2．    同样，拷贝构造函数MySingleton1(const MySingleton1&)也被声明为私有。

3．    全局的模板函数template <typename T> T& GetInstanceRef()是MySingleton1的友元。因为MySingleton1的构造函数已经声明为私有，为了让GetInstanceRef能顺利的构造静态变量_instance，我们不得不将它声明为MySingleton1的友元函数。



这样，我们的类MySingleton1就具有了Singleton特性了，而全局访问点就是两个模板函数。测试代码如下：

MySingleton1* myobj1;

myobj1 = GetInstancePtr<MySingleton1>();

myobj1->DoSomething();

GetInstanceRef<MySingleton1>().DoSomething();

    下面我们分析这种实现的缺点。由于模板函数GetInstanceRef被特化后要访问MySingleton1，它的声明必须在类（MySingleton1）声明之后（区分声明与实现），这与我们通常的使用方式不合。虽然它在其它方面表现的比较良好，但就这一个缺点已经使我不会再想使用它了。来看第二种可以实际使用的实现。



二、基于模板类的实现



    这种实现的基本思路是，做一个类让它来负责提供Singleton对象的生成与访问。由于它要构造Singleton对象，所以让它成为一个友元是理所当然的。下面看看实现代码：

template <typename T>

class SingletonWraper

{

public:

static T& GetInstanceRef()

{

    static T _instance;

    return _instance;

}

static const T& GetInstanceConst()

{

    return GetInstanceRef();

}     

static T* GetInstancePtr()

{

    return &GetInstanceRef();

}

};

#define DEFINE_SINGLETON(ClassName); \

public: \

friend class SingletonWraper<ClassName>; \

typedef class SingletonWraper<ClassName> SingletonWraper; \

typedef SingletonWraper SingletonInterface; \

private: \

ClassName(const ClassName&){} \

ClassName& operator=(const ClassName&) \

{ \

    return SingletonInterface::GetInstanceRef(); \

} \

private: //End of define DEFINE_SINGLETON(ClassName);

class MySingleton2

{

DEFINE_SINGLETON(MySingleton2);

private:

MySingleton2(){ cout << _T("Construct MySingleton2") << endl; }



public:

~MySingleton2(){ cout << _T("Destroy MySingleton2") << endl; }



public:

void DoSomething(){ cout << _T("Do something here in MySingleton2") << endl; }

};

    先看看SingletonWraper类，它提供的三个静态函数用于取得对Singleton对象的访问。再看下面的一个宏，它的作用是声明友元以及定义两个Singleton对象的访问点（SingletonWraper和SingletonInterface），并且，它还重载了拷贝构造函数以使访问的Singleton对象永远都是由GetInstanceRef惰性生成的一个实例。我们可以看见，使用这个SingletonWraper来包装Singleton类已经变得很简单了。我们只需要在需要Singleton化的类里面声明一条语句DEFINE_SINGLETON(MySingleton2);就可以了。但这还是有一些前提的，如构造函数（包括拷贝构造函数）私有以及析构函数公有。测试代码如下：

    MySingleton2* myobj2;

    myobj2 = SingletonWraper<MySingleton2>::GetInstancePtr();

    myobj2->DoSomething();

    MySingleton2::SingletonInterface::GetInstanceRef().DoSomething();



三、基于自身静态成员函数的实现



    这个实现不比前面的实现复杂，相反，更简单了。思路是从要实现Singleton的类自身入手，实现它的静态成员函数来提供全局的实例访问。这个实例的构造也是发生在它内部的一个静态成员函数里，所以，我们不用再使用友元来提供额外的访问权限。并且，我们也没有再使用任何模板。代码如下：

#define DECLARE_SINGLETON(ClassName); \

public: \

static ClassName& GetInstanceRef() \

{ \

    static ClassName _instance; \

    return _instance; \

} \

static const ClassName& GetInstanceConst() \

{ \

    return GetInstanceRef(); \

} \

static ClassName* GetInstancePtr() \

{ \

    return &GetInstanceRef(); \

} \

private: \

ClassName(const ClassName&){} \

ClassName& operator=(const ClassName&) \

{ \

    return GetInstanceRef(); \

} \

private: \

static void operator delete(void *p, size_t n) \

{ \

    ; /* 嘿嘿，什么都不要做.

        但要注意，析构函数已经执行。

          但对象并没有真正从内存卸载掉。*/ \

}//End of define DECLARE_SINGLETON(ClassName);



class MySingleton3

{

DECLARE_SINGLETON(MySingleton3);



private:

MySingleton3(){ cout << _T("Construct MySingleton3") << endl; }



public:

~MySingleton3(){ cout << _T("Destroy MySingleton3") << endl; }



public:

void DoSomething(){ cout << _T("Do something here in MySingleton3") << endl; }

};

实现Singleton的代码就一个宏定义而已，而使用它来使一个类拥有Singleton属性也只是调用一下这条宏。从使用上来看它应该是最简单的，看看下面的测试代码：

MySingleton3 *myobj3 = MySingleton3::GetInstancePtr();

myobj3->DoSomething();

delete myobj3;

MySingleton3::GetInstanceRef().DoSomething();

对比这里的测试代码和上一个的，可以发现，在使用过程中，这种方式也是最简单的。前面的三种方式都是在栈空间中创建对象，对象的销毁是在作用域边界上。细心的读者可能已经发现问题了。如果我们得到对象的指针后把它给delete了，则肯定就出问题了。对第一二种实现，我们没有重载delete操作符，delete之后指针将不再可用。而对第三种实现，我们有delete的重载函数，它阻止了对象的真正卸载。但在执行delete函数之前，析构函数已经执行了，因为全局的delete操作首先调用的是类的析构函数，再调用类的delete重载操作符函数。汇编代码清楚的显示了这一点：

MySingleton3::`scalar deleting destructor':

00412270  push        ebp

……

0041228D  mov        ecx,dword ptr [ebp-4]

00412290  call        @ILT+175(MySingleton3::~MySingleton3) (004010b4)

00412295  mov        eax,dword ptr [ebp+8]

00412298  and        eax,1

0041229B  test        eax,eax

0041229D  je          MySingleton3::`scalar deleting destructor'+3Dh (004122ad)

0041229F  push        4

004122A1  mov        ecx,dword ptr [ebp-4]

004122A4  push        ecx

004122A5  call        @ILT+70(MySingleton3::operator delete) (0040104b)

004122AA  add        esp,8

……

前面的三个实现中Singleton的全局唯一对象是自动创建(惰性初始化)并自动销毁（在作用域边界上），而程序员非要执行delete操作的话将是错误的，这好比我们在程序中执行如下一段代码。

int i(0);

int* p = &i;

delete p;

很显然，这是不被允许的。对这一点最好的处理方式是在delete的时候抛出一个异常，因为我们不允许程序员在这里使用delete操作。考虑下面的代码：

static void operator delete(void *p, size_t n) \

{ throw –1; }

相应的测试代码改为：

try { delete myobj3; /*试着卸载对象*/ }

catch(...) { cout << _T("Your object cannot be deleted.") << endl; /*失败*/ }



四、《Design Patterns》上的实现及其改进

    在《Design Patterns ---Elements of Reusable Object-Oriented Software》(英文版)第127页讨论Singleton模式时也给出了一个实现，但它存在一个严重的缺陷：没有考虑对象的销毁。以下是它给出的Sample代码：

class MazeFactory {

public:

static MazeFactory* Instance();



//existing interface goes here

protected:

MazeFactory();

private:

static MazeFactory* _instance;

};



MazeFactory* MazeFactory::_instance = 0;



MazeFactory* MazeFactory::Instance() {

if (_instance == 0) {

    _instance = new MazeFactory;

}

return _instance;

}

    先分析一下它的实现策略。首先是构造函数访问受限（protected），然后声明了一个静态的对象指针，该指针的初始化（或者说该类的实例化）是在静态成员函数Instance里面。这里它并没有相应的对象卸载代码，然而在自由存储空间（堆空间）里生成的对象是不会自动卸载的。所以，经过改进，我得到了下面的代码。

class MySingleton4

{

private:

MySingleton4(){ cout << _T("Construct MySingleton4") << endl; } //构造函数私有    ~MySingleton4(){ cout << _T("Destroy MySingleton4") << endl; } //析构函数放哪里都可以了

static MySingleton4* _instance;



public:

static MySingleton4& GetInstanceRef()

{

    if (_instance == 0)

        _instance = new MySingleton4;

    return *_instance;

}

static MySingleton4* GetInstancePtr()

{

    return &GetInstanceRef();

}

static ReleaseInstance()

{

    if (_instance != 0)

    {

        delete _instance;

        _instance = 0;

    }

}
public:

void DoSomething(){ cout << _T("Do something here in MySingleton4") << endl; }

};

MySingleton4* MySingleton4::_instance = 0; //Singleton对象初始化

static class DestructHelper //用于卸载MySingleton4对象的辅助类

{

public:

~DestructHelper(){ MySingleton4::ReleaseInstance(); }

} DestructHelperInstance; //辅助类静态实例

代码唯一的改进是增加了释放对象的静态函数ReleaseInstance。注意，在这个函数中_instance != 0判断以及后来的_instance = 0都是必不可少的，因为函数ReleaseInstance可能会被重复调用。将指针所指向的对象卸载后将指针置为0是一种非常好的编程习惯，它可以避免“野指针”的出现，而这通常是很危险的。接下来的类DestructHelper是用来辅助卸载MySingleton4的Singleton对象的，我们在它的公有析构函数里调用MySingleton4::ReleaseInstance()静态函数来完成工作。而DestructHelper的一个全局静态实例DestructHelperInstance会在适当的时候卸载掉，这就保证了析构函数~DestructHelper()得以被调用，从而卸载掉MySingleton4的Singleton对象。使用的时候，我们可以调用ReleaseInstance（）手动的卸载掉对象，然后再调用GetInstanceRef（）获得一个新的对象。如果我们不希望这样做，那么DestructHelperInstance的析构将保证堆空间里的对象得以被自动卸载。这样的处理方式增加了更多的灵活性。

但是，缺点还是有的。最主要的遗憾在于代码的重用上。第一、二种实现方式是基于模板技术的，代码可以很方便的重用，第三种方式虽然没有使用模板技术，但宏定义的使用也可以很好的保证代码的简单重用。最后的这种实现方式在代码重用上就显得稍微难了一点。我能想到的最佳解决办法仍然是使用宏（虽然我本人也很反对在C++里使用宏），一个用于定义MySingleton4类内部的处理，一个用于生成一个卸载辅助类的静态实例。第二个宏与模板有异曲同工的味道，不过，它还生成了一个与类型相关的静态变量。具体代码请见源程序清单。

五、结束语

本文全部代码在VC6.0里全部通过。

本文提出的只是作者写的几个比较简单的实现方式，但已经能满足大多数应用的需要了。更复杂的实现请参考http://www.hoversoft.net/devinfo/0205doc/20Singleton/index.htm。本文作者“油箱”：vcvbjava@yahoo.com。欢迎大家讨论，以求共同进步。