Ogre

——静下心,坐坐……
posts - 4, comments - 2, trackbacks - 0, articles - 3
  C++博客 :: 首页 :: 新随笔 :: 联系 :: 聚合  :: 管理
这是一篇论文,文章比较长,感兴趣的可以只看其中的部分内容。

============================================


摘  要 本文提出了三种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。欢迎大家讨论,以求共同进步。

只有注册用户登录后才能发表评论。
【推荐】超50万行VC++源码: 大型组态工控、电力仿真CAD与GIS源码库
网站导航: 博客园   IT新闻   BlogJava   知识库   博问   管理