单例模式----懒汉+饿汉

单例模式：
特点：仅有一个实例
实现：声明构造函数析构函数为私有,声明一个静态函数来创建和调用该实例。
分类：懒汉模式，饿汉模式
扩展：仅生成指定数量的实例

解决问题的一般方法：
从易到难，根据简单的实例理解问题的大致解决方法以及实现
-->再逐步加深难度，深入理解该问题的难点（人与人不同，难点也略有不同）
--->自己动手实现一遍
----->整理思路，找到解决问题的核心点
----->找到该问题的产生背景，以及应用范围
（本人能力有限，无法达到以上要求，哎，希望大能指点，共同进步。）

单例模式代码：

懒汉模式：延迟加载，什么时候用什么时候加载。

//单例模式------懒汉模式
#include <iostream>
using namespace std;

class Singleton {
public:
static Singleton * singleInstance(){
if ( pSingleton == NULL ){
return pSingleton = new Singleton();
}
return pSingleton ;
}

void destorySingleton ()
{
delete pSingleton ;
pSingleton = NULL ;
}

private:
static Singleton * pSingleton;
Singleton()
{
cout<<"My name is singleton!" <<endl;
}
~ Singleton()
{
cout<<"good bye!" <<endl;
}
};

Singleton* Singleton ::pSingleton = NULL;

int main ()
{
Singleton::singleInstance ();
Singleton::singleInstance ()->destorySingleton();
return 0 ;
}

[align=left]缺点：[/align]
[align=left] 懒汉模式是用时创建实例,我们注意到该类中有一个private static member ：pSingleton ,当有多个静态成员的时候，尤其是该类实例依赖成员的初始化顺序时候，我们无法保证静态成员的初始化顺序，这由编译器的“心情”决定：想先创建那个就先创建那个静态实例。[/align]
[align=left] 当单例模式类实例化的时候，如果对静态成员有次序要求，则会出现意想不到的结果，往往在某一个关键时刻给你一个“惊喜”，比如程序上次运行明明很好，但是这次刚刚启动就崩溃了。这是由于静态数据的初始化时没有次序的，这要看编译器的“心情”，想先初始化哪个就初始化哪个。程序员最讨厌不确定了，喜欢程序按部就班的执行，严格按照指令，一步一步执行。[/align]
[align=left] 在多线程的时候，可能实例化多个类实例。这需要加锁。（这里留下一个待执行任务：详述一下锁的机制）[/align]

[align=left]饿汉模式：程序执行时立即初始化实例，不用等到用时候再初始化。[/align]

//单例模式------饿汉模式
#include <iostream>
using namespace std;
class Singleton {
public:
static Singleton & singletonInstance (){
static Singleton s;
return s ;
}
private:
Singleton(){
cout<<"我是饿汉模式" <<endl;
}
~ Singleton(){
cout<<"饿汉模式走了，挥一挥手，不留下一片云彩。" <<endl;
}
static int a;
};

int main ()
{
Singleton::singletonInstance ();
return 0;
}

优点：
节省堆栈空间，静态数据放在全局数据区。局部静态成员第一次使用时候初始化，即初始化次序可控。可像懒汉模式一样，等到用时候再初始化。
注意：
两个类不可相互引用。多线程中，由于类的构造函数不是原子操作，我们在初始化类的时候还是要加锁（未完成：哪些操作是原子操作）。

扩展：
有时候我们需要实例化的对象有上限，即实例化对象个数可控。

使用信号量解决（未完成：进程间通信）。

参考：http://blog.yangyubo.com/2009/06/04/best-cpp-singleton-pattern/ http://blog.csdn.net/lingfengtengfei/article/details/12347089