C++实现单件的初探

在《设计模式》中有一个叫做单件(Sigleton)的模式,是用来控制创建唯一对象。书中只讲到了如何建立Singleton对象
，对于如何来销毁此对象则只字不提。但是对象生命的管理对于C++程序员来说是多么的重要呀。或许Singleton只
是属于创建模式的一种，大师们认为在这里不应涉及到“销毁模式”。

有人认为Sinleton是应该在程序的退出的时候销毁的。但是退出应该是在什么时候呢。
请看如下代码:
假设是按设计模式里的方式来写一个对象Singlton对象。

class Singlton
{
private:
    static Singlton * _insatnce;
    Singlton()
    {
        cout<<"object is ["<<this<<"] Do< Construction"<<endl;
    }
public:
    ~Singlton()
    {
        cout<<"object is ["<<this<<"] Do Destruction>"<<endl;
        _insatnce = 0;
    }

    static Singlton * GetSinglton()
    {
        if(_insatnce)
            return _insatnce;
    
        _insatnce = new Singlton;
       
        return _insatnce;
    }
    void Dosomething()
    {
        cout<<"object is ["<<this<<"] Do Something"<<endl;
    }
};

Singlton * Singlton::_insatnce = NULL;

void foo(int i)
{
    /*

        程序体
    */
    if(i)
        Singlton::GetSinglton()->Dosomething();
    /*

        程序体
    */
}
int main()
{
    /*
        void ;
        程序体
    */
    foo(1)

//  if(Singlton::_insatnce) 
//       Singlton::GetSinglton(); 不能编译
    delete Singlton::GetSinglton();
}

事实上如果在Singlton某次运行根本就没有调用过foo(1)而只是调用了foo(0),但是还必
须得在最后程序退出时调用实际上这时候调用GetSinglton()来建立对象马上就被删除了
。这是完全没有必要也是浪费的。想在程序执行时使用判断语句也是行不通的。这样的实
现还是可以改进的,使用在Singlton中再增加一个静态的成员函数CheckExistInstance来判
断对象是否存在,可以提高效率。但这样又给对象增加了接口，增加了代码维护的开销。

但是对象在程序结束时你并不清楚是不是真的不再需要此对象了。我们再修改代码如下。

class Singlton
{
private:
    static Singlton * _insatnce;
    Singlton()
    {
        cout<<"object is ["<<this<<"] Do< Construction"<<endl;
    }
public:
    ~Singlton()
    {
        cout<<"object is ["<<this<<"] Do Destruction>"<<endl;
        _insatnce = 0;
    }

    static Singlton * GetSinglton()
    {
        if(_insatnce)
            return _insatnce;
    
        _insatnce = new Singlton;
       
        return _insatnce;
    }
    void Dosomething()
    {
        cout<<"object is ["<<this<<"] Do Something"<<endl;
    }
};

Singlton * Singlton::_insatnce = NULL;

void foo(int i)
{
    /*

        程序体
    */
    if(i)
        Singlton::GetSinglton()->Dosomething();
    /*

        程序体
    */
}

class TestSingleton
{
public:
    TestSingleton()
    {
        Singlton::GetSinglton()->Dosomething();
    }
    ~TestSingleton()
    {
        Singlton::GetSinglton()->Dosomething();//此处出现内存泄露
    }
};
TestSingleton _test;
int main()
{
    /*
        void ;
        程序体
    */
    foo(1);

    delete Singlton::GetSinglton();
}

且看~TestSingleton()申请出来的对象应该由谁来释放呢。由此引发了有人主张使用
引用记数器由模仿COM的Release来实现.实现代码如下
class Singleton
{
private:
    static int m_Ref;
    static Singleton * _instance;
public:
    void DoSomething()
    {
        cout<<"object is ["<<this<<"] Do Something"<<endl;
    }

    static Singleton * GetSinglton()
    {
        if(_instance)
        {
            ++m_Ref;
            return _instance;
        }
        _instance = new Singleton;
        ++m_Ref;
        return _instance;
    }
   
    ULONG Release()
    {
        --m_Ref;
        if(0 == m_Ref)
        {
            delete _instance;
            _instance = NULL;
            return 0;
        }
        return m_Ref;
    }
private:
    Singleton()
    {
        cout<<"object is ["<<this<<"] Do< Construction"<<endl;
    }
    ~Singleton()
    {
        cout<<"object is ["<<this<<"] Do Destruction>"<<endl;
    }
};
Singleton *Singleton::_instance = NULL;
int Singleton::m_Ref = 0;

void foo()
{
    Singleton * p = Singleton::GetSinglton();
    p->DoSomething();
    p->Release();
}

int _tmain(int argc, TCHAR* argv[], TCHAR* envp[])
{
    Singleton * p = Singleton::GetSinglton();
    p->DoSomething();
    p->Release();

    foo();
    return 0;
}

这样的方式是不存在内存泄露的，并且这段代码表面上是个单件；实际上,
Singleton对象是被多次建立和销毁的，如果这个对象不像以上代码写得那么简单,
是如果在单件中申请了不小的内存，那么以上的代码是多么的不可想象呀！更有如
果单件里记录了像使用次数那样的状态变量，那情况就更糟糕了。
事实上单件的实现并不比想像中的那样难。我们且看

class Singlton
{
private:
    Singlton()
    {
        cout<<"object is ["<<this<<"] Do< Construction"<<endl;
    }
public:
    ~Singlton()
    {
        cout<<"object is ["<<this<<"] Do Destruction>"<<endl;
    }

    static Singlton & GetSinglton()
    {
        static Singlton s;
        return s;
    }
    void Dosomething()
    {
        cout<<"object is ["<<this<<"] Do Something"<<endl;
    }
};

void foo(int i)
{
    /*

        程序体
    */
    if(i)
        Singlton::GetSinglton().Dosomething();
    /*

        程序体
    */
}
class TestSinglton
{
public:
    TestSinglton()
    {
    Singlton::GetSinglton().Dosomething();
    }
    ~TestSinglton()
    {
    Singlton::GetSinglton().Dosomething();
    }
};
TestSinglton test1;
int main()
{
    /*
        void ;
        程序体
    */
    TestSinglton test2;
    foo(1);
    return 0;
}

这里用到的一个技巧就是使用了静态的变量,很明显有如下的好处：

1)如果在此次运行时根本没有用到单件，对像是不会被建立的。
2)需要用户来关心对象的释放
3)完全符合设计要求
...
我想正是很多人梦寐以求的实现。:)

本文地址：http://com.8s8s.com/it/it2309.htm