单件模式的析构
第一种单件模式的实现:
C/C++ code
class CSingleton1{
private:
CSingleton1(){
cout<<"CSingleton1 constructor"<<endl;
}
CSingleton1& operator=(CSingleton1& o){}
CSingleton1& operator()(CSingleton1& o){}
public:
virtual ~CSingleton1(){
cout<<"CSingleton1 destructor"<<endl;
}
static CSingleton1& getInstance()
{
static CSingleton1 instance;
return instance;
}
};
int main()
{
CSingleton1 a1 = CSingleton1::getInstance();
CSingleton1 b1 = CSingleton1::getInstance();
}
析构三次,可以理解,a1析构一次,a2析构一次,类静态函数里的静态变量析构一次. 但很不爽
第二种实现:
C/C++ code
class CSingleton2{
private:
CSingleton2()
{
cout<<"CSingleton2 constructor"<<endl;
}
CSingleton2 & operator=(CSingleton2 & o){}
CSingleton2 & operator()(CSingleton2 & o){}
static CSingleton2 *instance;
public:
virtual ~CSingleton2()
{
if(NULL!=instance)
{
cout<<"CSingleton2 destructor"<<endl;
delete instance;
instance=NULL;
}
}
static CSingleton2& getInstance()
{
if(NULL==instance)
{
instance=new CSingleton2();
}
return *instance;
}
};
int main()
{
CSingleton2 a2 = CSingleton2::getInstance();
CSingleton2 b2 = CSingleton2::getInstance();
delete &a2;
}
这样更崩溃了,一个delete用调用析构函数,析构函数再用一个delete,然后又是析构函数......无限循环了.
哭啊,请问各位怎么用C++实现单件模式的析构!!!
------解决方案--------------------
第二种是基于指针实现的,没法做到自动析构。所以你不应该在析构函数里再delete。
除非你再用别的类包装一下,只是那样更没意思了。
单件模式的实现未必都能做到自动析构,到底用哪种,看你自己的权衡了。