在程序中，如果new了一个对象，那么就应该负责对象的delete，但是如果这个对象是一个单例类的实例，那么对象销毁的时候就可能出现一些问题，例如Person是一个单例的类，但是同时有A,B,C三个人new了一个Person类的对象，那么A,B,C三个人得到的是同一个实例对象，但是可能发生A在用完这个对象之后执行了delete操作，导致仍然在使用这个对象的B,C出现错误。
为了解决这个问题，可以在这个单例类中增加一个静态成员变量来记录实例化这个类的次数，来确保执行delete操作的时候已经没人需要使用这个对象。
示例如下：
#include
using namespace std;
//单例类的C++实现
class Singleton
{
private:
Singleton();//注意:构造方法私有
static Singleton* instance;//惟一实例
int var;//成员变量(用于测试)
public:
static int counter; //类实例化的次数
static Singleton* GetInstance();//工厂方法(用来获得实例)
int getVar();//获得var的值
void setVar(int);//设置var的值
virtual ~Singleton();
void ReleaseInstance();
};
//构造方法实现
Singleton::Singleton()
{
this->var = 20;
cout<<"Singleton Constructor"<
}
Singleton::~Singleton()
{
cout<<"Singleton Destructor"<
}
int Singleton::counter = 0;
Singleton* Singleton::instance=NULL;
Singleton* Singleton::GetInstance()
{
counter ++;
if(instance == NULL)
{
instance = new Singleton();
}
return instance;
}
void Singleton::ReleaseInstance()
{
counter--;
if(counter==0)
delete instance;
}
int Singleton::getVar()
{
return this->var;
}
void Singleton::setVar(int var)
{
this->var = var;
}
//main
int main()
{
Singleton *ton1 = Singleton::GetInstance();
cout<
Singleton *ton2 = Singleton::GetInstance();
cout<
if(ton1==ton2)
cout<<"ton1==ton2"<
cout<<"ton1 var = "<
getVar()<
cout<<"ton2 var = "<
getVar()<
ton1->setVar(150);
cout<<"ton1 var = "<
getVar()<
cout<<"ton2 var = "<
getVar()<
ton1->ReleaseInstance();
cout<
ton2->ReleaseInstance();
cout<
return 0;
}
运行结果如下：
Singleton Constructor
1
2
ton1==ton2
ton1 var = 20
ton2 var = 20
ton1 var = 150
ton2 var = 150
1
Singleton Destructor
0
可以看到，实例化2次之后，counter==2，第一次调用ReleaseInstance函数，还有ton2在使用这个对象，此时执行counter--后，counter=1不执行delete操作。第二次调用后counter=0，执行delete，调用了类的析构函数，正确销毁了这个单例对象。
使用这种方法，每个人在用完自己new的对象之后，都可以放心的调用ReleaseInstance函数，不会影响别人的使用，而且确保在所有的人使用完之后，对象会及时的销毁.
原文地址：
阅读(1212) | 评论(0) | 转发(1) |
