#include<iostream>
using namespace std;
class singleton
{
public:
static singleton* getinstance()
{
if(NULL==instance)
{instance=new singleton;}
return instance;
}
~singleton()
{cout<<"~singleton..."<<endl;}
//通过定义一个静态函数显示调用析构函数,但是这种方式不够灵活,因为不
//知道在什么地方该将这个单例对象析构掉。因此,这种方式不可取。
/*static void free()
{
if(instance!=NULL)
{
delete instance;
}
}*/
//为了实现单例对象的自动析构,通过确定性析构的小技巧,来达到自动析构的目的,析构函数应当是
//public的,否则的话,不能够实现析构的目的。通过类中类的方法,感觉仍然是不够好。
/*class garbo
{
public:
~garbo()
{
if (instance!=NULL)
{
delete instance;
}
}
};*/
private:
//在保证不允许随意的构造对象时,可以将构造函数放在private中。
singleton()
{cout<<"singleton...."<<endl;}
//将拷贝构造函数和赋值构造函数放在private之中,禁止拷贝!
singleton(const singleton&other);
singleton& operator=(const singleton&other);
static singleton* instance;//引用性申明
//static garbo s;//引用性申明
};
singleton* singleton::instance;//定义性申明
//singleton::garbo singleton::s;//定义性申明
int main(void)
{
singleton *s1= singleton::getinstance();
singleton *s2= singleton::getinstance();
//singleton s3(*s1);
//singleton::free();
return 0;
}
通过一个局部静态对象的方式,可以更好的实现单例模式,所以这里有了如下的改进:
#include<iostream>
using namespace std;
class singleton
{
public:
static singleton &getinstance()
{
/*if(NULL==instance)
{instance=new singleton;}*/
static singleton instance;//局部静态对象,在运行时候初始化,因为是静态的,所以它的状态得到保存,第二
//次构造singleton的实例的时候,不会再分配内存。
return instance;
}
~singleton()
{cout<<"~singleton..."<<endl;}
//通过定义一个静态函数显示调用析构函数,但是这种方式不够灵活,因为不
//知道在什么地方该将这个单例对象析构掉。因此,这种方式不可取。
/*static void free()
{
if(instance!=NULL)
{
delete instance;
}
}*/
//为了实现单例对象的自动析构,通过确定性析构的小技巧,来达到自动析构的目的,析构函数应当是
//public的,否则的话,不能够实现析构的目的。通过类中类的方法,感觉仍然是不够好。
/*class garbo
{
public:
~garbo()
{
if (instance!=NULL)
{
delete instance;
}
}
};*/
private:
//在保证不允许随意的构造对象时,可以将构造函数放在private中。
singleton()
{cout<<"singleton...."<<endl;}
//将拷贝构造函数和赋值构造函数放在private之中,禁止拷贝!
singleton(const singleton&other);
singleton& operator=(const singleton&other);
//static singleton* instance;//引用性申明
//static garbo s;//引用性申明
};
//singleton* singleton::instance;//定义性申明
//singleton::garbo singleton::s;//定义性申明
int main(void)
{
singleton &s1= singleton::getinstance();
singleton &s2= singleton::getinstance();
//singleton s3(*s1);
//singleton::free();
return 0;
}
当然,还有其他的方式,如下:
#include<iostream>
using namespace std;
class singleton
{
public:
static singleton* getinstance()
{
/*if(NULL==instance)
{instance=new singleton;}*/
static singleton instance;//局部静态对象,在运行时候初始化,因为是静态的,所以它的状态得到保存,第二
//次构造singleton的实例的时候,不会再分配内存。
return &instance;
}
~singleton()
{cout<<"~singleton..."<<endl;}
//通过定义一个静态函数显示调用析构函数,但是这种方式不够灵活,因为不
//知道在什么地方该将这个单例对象析构掉。因此,这种方式不可取。
/*static void free()
{
if(instance!=NULL)
{
delete instance;
}
}*/
//为了实现单例对象的自动析构,通过确定性析构的小技巧,来达到自动析构的目的,析构函数应当是
//public的,否则的话,不能够实现析构的目的。通过类中类的方法,感觉仍然是不够好。
/*class garbo
{
public:
~garbo()
{
if (instance!=NULL)
{
delete instance;
}
}
};*/
private:
//在保证不允许随意的构造对象时,可以将构造函数放在private中。
singleton()
{cout<<"singleton...."<<endl;}
//将拷贝构造函数和赋值构造函数放在private之中,禁止拷贝!
singleton(const singleton&other);
singleton& operator=(const singleton&other);
//static singleton* instance;//引用性申明
//static garbo s;//引用性申明
};
//singleton* singleton::instance;//定义性申明
//singleton::garbo singleton::s;//定义性申明
int main(void)
{
singleton *s1= singleton::getinstance();
singleton *s2= singleton::getinstance();
//singleton s3(*s1);
//singleton::free();
return 0;
}
效果相同,结果是对象被构造一次,也被析构一次,防止资源泄露。