设计模式——单例模式Singleton

首先看看《设计模式》中对单例模式的实现，主要使用类的私有静态指针变量指向类的唯一实例，并向外提供一个公有静态方法获取该实例。

代码如下：

class CSingleton:    
{    
    // 其它成员    
public:    
    static CSingleton * GetInstance()    
    {    
        if (m_pInstance == NULL)    
            m_pInstance = new CSingleton();    
        return m_pInstance;    
    }    
     
private:    
    CSingleton(){};    
    static CSingleton * m_pInstance;    
}  

单例类CSingleton有以下特征：

◆它有一个指唯一实例的静态指针m_pInstance，并且是私有的。

◆它有一个公有的函数，可以获取这个唯一的实例，并在需要的时候创建该实例。

◆它的构造函数是私有的，这样就不能从别处、通过别的方式创建该类的实例。 

由于单例对象是通过new操作符在堆上创建，所以在程序执行时，为了避免内存泄露需要显式调用delete。这时候问题来了，什么时候应该释放这个m_pInstance指向的单例对象呢？如果在某一处调用了delete从而析构了对象，则会导致另外一处的原单例对象指针失效；另外，如果在//其它成员中有使用了外部资源或者打开了文件等，那么这些资源该如何释放呢？上面所示的代码无法实现这个要求，我们需要一种方法，可以正常地删除该实例、释放相关资源。

方法很简单，使用单例+引用计数。代码如下：

class Singleton
{
	static Singleton * s;
	int mark;
	static int count_ref;
	Singleton(int i):mark(i){};
	~Singleton(){cout << "Destory now!" << endl;}

public:
	static Singleton * get_instance(int i);
	void print_s(){cout << this->mark << endl;}
	void finish_s();
};

int Singleton::count_ref = 0;
Singleton* Singleton::s = 0;
Singleton * Singleton::get_instance(int i)
{
	if(s == 0)
		s = new Singleton(i);
	count_ref++;
	return s;

};
void Singleton::finish_s()
{
	if(count_ref > 1)
	{
		count_ref--;
		cout << count_ref << " left!" << endl;
	}else
	{
		cout  << "No one left!" << endl;
		delete this;
	}
}
void local_fuction()
{
	Singleton * s = Singleton::get_instance(2);
	s->print_s();
	//finished!
	s->finish_s();

}
int main()
{
	Singleton * ptr = Singleton::get_instance(1);
	ptr->print_s();
	local_fuction();
	ptr->finish_s();

	system("pause");
}

每次使用Singleton::get_instance获取类的实例，在完成所需的操作（print_s)后，都调用finish_s。最后一个对单例对象的引用释放时，则释放对象占用的空间。注意，可以在析构函数中，关闭打开的文件、释放外部资源等。