单件模式【C++】【转载】
2013-05-21 12:45
302 查看
单例模式也称为单件模式、单子模式。使用单例模式,保证一个类仅有一个实例,并提供一个访问它的全局访问点,该实例被所有程序模块共享。有很多地方需要这样的功能模块,如系统的日志输出等。
单例模式有许多种实现方法,在C++中,甚至可以直接用一个全局变量做到这一点,但这样的代码显得很不优雅。《设计模式》一书中给出了一种很不错的实现,定义一个单例类,使用类的私有静态指针变量指向类的唯一实例,并用一个公有静态方法获取该实例。如下面的类定义:
[align=left]class CSingleton:[/align]
[align=left]{[/align]
//
其它成员
[align=left]public:[/align]
[align=left] static CSingleton * GetInstance()[/align]
[align=left] {[/align]
if (m_pInstance == NULL)
m_pInstance =
new CSingleton();
return m_pInstance;
[align=left] }[/align]
[align=left]private:[/align]
[align=left] CSingleton(){};[/align]
[align=left] static CSingleton * m_pInstance;[/align]
}
单例类CSingleton有以下特征:
?
它有一个指唯一实例的静态指针m_pInstance,并且是私有的。
?
它有一个公有的函数,可以获取这个唯一的实例,并在需要的时候创建该实例。
?
它的构造函数是私有的,这样就不能从别处创建该类的实例。
大多时候,这样的实现都不会出现问题。有经验的读者可能会问,m_pInstance指向的空间什么时候释放呢?更严重的问题是,这个实例的析构操作什么时候执行?
如果在类的析构行为中有必须的操作,比如关闭文件,释放外部资源,那么上面所示的代码无法实现这个要求。我们需要一种方法,正常地删除该实例。
可以在程序结束时调用GetInstance并对返回的指针调用delete操作。这样做可以实现功能,但是不仅很丑陋,而且容易出错。因为这样的附加代码很容易被忘记,而且也很难保证在delete之后,没有代码再调用GetInstance函数。
一个妥善的方法是让这个类自己知道在合适的时候把自己删除。或者说把删除自己的操作挂在系统中的某个合适的点上,使其在恰当的时候自动被执行。
我们知道,程序在结束的时候,系统会自动析构所有的全局变量。事实上,系统也会析构所 有的类的静态成员变量,就像这些静态成员也是全局变量一样。利用这个特征,我们可以在单例类中定义一个这样的静态成员变量,而它的唯一工作就是在析构函数 中删除单例类的实例。如下面的代码中的CGarbo类(Garbo意为垃圾工人):
[align=left]class CSingleton:[/align]
[align=left]{[/align]
//
其它成员
[align=left]public:[/align]
[align=left] static CSingleton * GetInstance(){。。。}[/align]
[align=left]private:[/align]
[align=left] CSingleton(){};[/align]
[align=left] static CSingleton * m_pInstance;[/align]
class CGarbo
// 它的唯一工作就是在析构函数中删除CSingleton的实例
[align=left] {[/align]
[align=left] public:[/align]
[align=left] ~CGarbo()[/align]
[align=left] {[/align]
if (CSingleton::m_pInstance)
delete CSingleton::m_pInstance;
[align=left] }[/align]
[align=left] }; [/align]
static CGarbo Garbo;
// 定义一个静态成员,在程序结束时,系统会调用它的析构函数
}
类CGarbo被定义为CSingleton的私有内嵌类,以防该类被在其它地方滥用。
在程序运行结束时,系统会调用CSingleton的静态成员Garbo的析构函数,该析构函数会删除单例的唯一实例。
使用这种方法释放单例对象有以下特征:
?
在单例类内部定义专有的嵌套类。
?
在单例类内定义私有的专门用于释放的静态成员。
?
利用程序在结束时析构全局变量的特性,选择最终的释放时机。
?
使用单例的代码不需要任何操作,不必关心对象的释放。
Singleton模式是设计模式中最简单的模式,很多人学习设计模式都是从这个模式开始学习的,但是该模式仍然有许多细节往往被大家忽略。
一、 Singleton模式的作用
Singleton模式提供了一个全局唯一访问类的方法,它在整个程序中只有一个实例,不允许出现多个。作用类似于全局变量。但是全局变量的类型依然可以实例化多个对象,从而不能保证唯一性,所以必须采用Singleton模式。
程序中经常将某种管理类,以Singleton模式实现,比如资源管理、路径服务、网络访问处理,这些在整个程序中都应该只有一个实例。
二、 Singleton模式的要点
要点1:Singleton类的构造函数必须是非Public的(及Private或Protected), 从而避免外部实例化该对象;
要点2:自己实例化自己;
要点3: Singleton类必须提供一个访问自己的接口(靠static声明的函数访问);
三、Singleton模式的2种方式
1. 懒汉式
class Singleton
...{
private:
Singleton()...{}
~Singleton()...{}
public:
static Singleton& GetSingleton()
... {
static Singleton s_instance;
return s_instance;
}
void DoSomething()
... {
std::cout << "Singleton Do Something!";
}
};
解析:之所以称为懒汉式,是因为使用该类的时候啥都不管,不管他的初始化,也不管他的释放,用的时候就Singleton::GetSingleton().Func()就行了;
第一次调用该类的静态方法GetSingleton()的时候,进行实例化;由于声明的变量是static的,所以会在全局/静态空间一直保持该变量,以 后使用执行该方法的时候都不会再有构造发生,从而保证了唯一性。同时由于static变量是在全局空间,当程序结束的时候,他会自动释放;
懒汉式还有一种实现方式:
class Singleton
{
private:
Singleton() {}
~Singleton(){}
static Singleton* s_instance;
public:
static Singleton* GetSingleton()
{
if ( !s_instance)
{
s_instance = new Singleton();
}
return s_instance;
}
void DoSomething()
{
std::cout << "Singleton Do Something!";
}
void Release()
{
If( s_instance)
{
delete s_instance;
s_instance = NULL;
}
}
};
Singleton* Singleton::s_instance = NULL;
解析:这种方式由于是new出来的,对象是存储在栈空间中的,所以使用完后需要delete掉,通常提供一个Release()的方法,在不使用该类得时候释放掉他。由于需要手动释放,所以我一般不采用该方式;
2. 开关式
以上两种方法的初始化方式称为lazy initialization,及是在第一次需要实例的时候才创建类的实例,对于初始化过程比较简单的类,可以使用以上方式,对于初始化过程比较麻烦、占 用资源比较多的类,则应该在程序初始化的时候就实例化该类,不需要的时候就释放。以下是经常采用的方式:
class Singleton
{
private:
Singleton()
{
}
~Singleton(){}
static Singleton* s_instance;
static bool s_bOpen;
public:
static void Open()
{
if ( (s_bOpen == false) && (s_instance == NULL))
{
s_instance = new Singleton();
}
}
static void Close()
{
if ( s_bOpen && s_instance)
{
delete s_instance;
s_instance = NULL;
}
}
static Singleton* GetSingleton()
{
Singleton* tempInstance = NULL;
if ( s_bOpen)
{
if ( s_instance)
{
tempInstance = s_instance;
}
}
else
{
assert( false && "Singleton is not open");
}
return s_instance;
}
void DoSomething()
{
std::cout << "Singleton Do Something!";
}
};
Singleton* Singleton::s_instance = NULL;
bool Singleton::s_bOpen = false;
单例模式有许多种实现方法,在C++中,甚至可以直接用一个全局变量做到这一点,但这样的代码显得很不优雅。《设计模式》一书中给出了一种很不错的实现,定义一个单例类,使用类的私有静态指针变量指向类的唯一实例,并用一个公有静态方法获取该实例。如下面的类定义:
[align=left]class CSingleton:[/align]
[align=left]{[/align]
//
其它成员
[align=left]public:[/align]
[align=left] static CSingleton * GetInstance()[/align]
[align=left] {[/align]
if (m_pInstance == NULL)
m_pInstance =
new CSingleton();
return m_pInstance;
[align=left] }[/align]
[align=left]private:[/align]
[align=left] CSingleton(){};[/align]
[align=left] static CSingleton * m_pInstance;[/align]
}
单例类CSingleton有以下特征:
?
它有一个指唯一实例的静态指针m_pInstance,并且是私有的。
?
它有一个公有的函数,可以获取这个唯一的实例,并在需要的时候创建该实例。
?
它的构造函数是私有的,这样就不能从别处创建该类的实例。
大多时候,这样的实现都不会出现问题。有经验的读者可能会问,m_pInstance指向的空间什么时候释放呢?更严重的问题是,这个实例的析构操作什么时候执行?
如果在类的析构行为中有必须的操作,比如关闭文件,释放外部资源,那么上面所示的代码无法实现这个要求。我们需要一种方法,正常地删除该实例。
可以在程序结束时调用GetInstance并对返回的指针调用delete操作。这样做可以实现功能,但是不仅很丑陋,而且容易出错。因为这样的附加代码很容易被忘记,而且也很难保证在delete之后,没有代码再调用GetInstance函数。
一个妥善的方法是让这个类自己知道在合适的时候把自己删除。或者说把删除自己的操作挂在系统中的某个合适的点上,使其在恰当的时候自动被执行。
我们知道,程序在结束的时候,系统会自动析构所有的全局变量。事实上,系统也会析构所 有的类的静态成员变量,就像这些静态成员也是全局变量一样。利用这个特征,我们可以在单例类中定义一个这样的静态成员变量,而它的唯一工作就是在析构函数 中删除单例类的实例。如下面的代码中的CGarbo类(Garbo意为垃圾工人):
[align=left]class CSingleton:[/align]
[align=left]{[/align]
//
其它成员
[align=left]public:[/align]
[align=left] static CSingleton * GetInstance(){。。。}[/align]
[align=left]private:[/align]
[align=left] CSingleton(){};[/align]
[align=left] static CSingleton * m_pInstance;[/align]
class CGarbo
// 它的唯一工作就是在析构函数中删除CSingleton的实例
[align=left] {[/align]
[align=left] public:[/align]
[align=left] ~CGarbo()[/align]
[align=left] {[/align]
if (CSingleton::m_pInstance)
delete CSingleton::m_pInstance;
[align=left] }[/align]
[align=left] }; [/align]
static CGarbo Garbo;
// 定义一个静态成员,在程序结束时,系统会调用它的析构函数
}
类CGarbo被定义为CSingleton的私有内嵌类,以防该类被在其它地方滥用。
在程序运行结束时,系统会调用CSingleton的静态成员Garbo的析构函数,该析构函数会删除单例的唯一实例。
使用这种方法释放单例对象有以下特征:
?
在单例类内部定义专有的嵌套类。
?
在单例类内定义私有的专门用于释放的静态成员。
?
利用程序在结束时析构全局变量的特性,选择最终的释放时机。
?
使用单例的代码不需要任何操作,不必关心对象的释放。
Singleton模式是设计模式中最简单的模式,很多人学习设计模式都是从这个模式开始学习的,但是该模式仍然有许多细节往往被大家忽略。
一、 Singleton模式的作用
Singleton模式提供了一个全局唯一访问类的方法,它在整个程序中只有一个实例,不允许出现多个。作用类似于全局变量。但是全局变量的类型依然可以实例化多个对象,从而不能保证唯一性,所以必须采用Singleton模式。
程序中经常将某种管理类,以Singleton模式实现,比如资源管理、路径服务、网络访问处理,这些在整个程序中都应该只有一个实例。
二、 Singleton模式的要点
要点1:Singleton类的构造函数必须是非Public的(及Private或Protected), 从而避免外部实例化该对象;
要点2:自己实例化自己;
要点3: Singleton类必须提供一个访问自己的接口(靠static声明的函数访问);
三、Singleton模式的2种方式
1. 懒汉式
class Singleton
...{
private:
Singleton()...{}
~Singleton()...{}
public:
static Singleton& GetSingleton()
... {
static Singleton s_instance;
return s_instance;
}
void DoSomething()
... {
std::cout << "Singleton Do Something!";
}
};
解析:之所以称为懒汉式,是因为使用该类的时候啥都不管,不管他的初始化,也不管他的释放,用的时候就Singleton::GetSingleton().Func()就行了;
第一次调用该类的静态方法GetSingleton()的时候,进行实例化;由于声明的变量是static的,所以会在全局/静态空间一直保持该变量,以 后使用执行该方法的时候都不会再有构造发生,从而保证了唯一性。同时由于static变量是在全局空间,当程序结束的时候,他会自动释放;
懒汉式还有一种实现方式:
class Singleton
{
private:
Singleton() {}
~Singleton(){}
static Singleton* s_instance;
public:
static Singleton* GetSingleton()
{
if ( !s_instance)
{
s_instance = new Singleton();
}
return s_instance;
}
void DoSomething()
{
std::cout << "Singleton Do Something!";
}
void Release()
{
If( s_instance)
{
delete s_instance;
s_instance = NULL;
}
}
};
Singleton* Singleton::s_instance = NULL;
解析:这种方式由于是new出来的,对象是存储在栈空间中的,所以使用完后需要delete掉,通常提供一个Release()的方法,在不使用该类得时候释放掉他。由于需要手动释放,所以我一般不采用该方式;
2. 开关式
以上两种方法的初始化方式称为lazy initialization,及是在第一次需要实例的时候才创建类的实例,对于初始化过程比较简单的类,可以使用以上方式,对于初始化过程比较麻烦、占 用资源比较多的类,则应该在程序初始化的时候就实例化该类,不需要的时候就释放。以下是经常采用的方式:
class Singleton
{
private:
Singleton()
{
}
~Singleton(){}
static Singleton* s_instance;
static bool s_bOpen;
public:
static void Open()
{
if ( (s_bOpen == false) && (s_instance == NULL))
{
s_instance = new Singleton();
}
}
static void Close()
{
if ( s_bOpen && s_instance)
{
delete s_instance;
s_instance = NULL;
}
}
static Singleton* GetSingleton()
{
Singleton* tempInstance = NULL;
if ( s_bOpen)
{
if ( s_instance)
{
tempInstance = s_instance;
}
}
else
{
assert( false && "Singleton is not open");
}
return s_instance;
}
void DoSomething()
{
std::cout << "Singleton Do Something!";
}
};
Singleton* Singleton::s_instance = NULL;
bool Singleton::s_bOpen = false;
相关文章推荐
- C++ 单件模式剖析(转载)
- C++设计模式-单件
- Singleton(简单单件模式)C++代码
- 设计模式 - 单件模式 C++
- c++ 单件模式
- C++单件模式(只保留唯一个类对象)
- Python和Singleton (单件)模式[转载]
- 单件模式的基类,C++
- 单件模式的C++模板实现
- C++ 单件模式实现及对象释放
- c++ 设计模式之单件模式
- 设计模式——单键模式(singleton)C++实现 【转载】
- C++设计模式(转载)
- 设计模式 单件模式(Signleton Pattern)转载
- C++中如何实现单件模式
- 转载:C++设计模式之Bridge模式 http://www.cnblogs.com/chain2012/archive/2011/01/17/1937528.html
- 关于C++单件模式释放对象
- C++设计模式之五:SINGLETON(单件模式)
- c++ 举例 单件模式 .....
- C++ 工厂模式和策略模式以及单件模式小练习