单例模式----饿汉

        单例模式是设计模式中最简单、最常见、最容易实现的一种模式，单例模式的主要思想是保证整个系统中一个类只有一个实例对象，并提供一个访问它的全局访问点，该实例被整个程序模块共享。实现方法一般是将构造函数、拷贝构造函数和赋值运算符重载函数声明为私有，这样可以避免他人创建实例，在提供一个共有的静态方法获得这个类唯一的一个实例化对象。
单例模式一般有两种实现模式：
饿汉模式：所谓饿汉，就是饿了饥不择食，在类定义的时候就进行初始化，以空间换时间。
懒汉模式：所谓懒汉，就是不到万不得已就不是去实例化，第一次用到类实例的时候才会去实例化，以时间换空间。

本文先对饿汉模式进行分析：
        饿汉模式的对象在类定义的时候就创建了，一直到程序结束时才释放，作为一个单例类的实例，它的生命周期和程序一样长，因此该实例对象需要存储在全局数据区，用static修饰，static修饰的成员不属于每个对象，属于整个类。在加载类的时候，实例对象就产生了，对于饿汉模式而言，线程是安全的，因为在线程创建之前实例已经创建好了。

下面实现了一个饿汉模式

#include <iostream>
using namespace std;

class Singleton
{
private:
	Singleton();
	Singleton(const Singleton&);
	Singleton& operator=(const Singleton&);
	~Singleton();
	static Singleton _instance;//定义一个实例对象，它是一个类对象
public:
	static Singleton* Instance();
};

Singleton :: Singleton()
{
	cout << "创建了一个单例对象" << endl; 
}

Singleton :: ~Singleton()
{
	cout << "销毁了一个单例对象" << endl; 
}

Singleton Singleton :: _instance; 

Singleton* Singleton :: Instance()
{
	return &_instance;
}

int main()
{
	cout<<"Now get a instance"<<endl;
	Singleton* sgn1 = Singleton ::Instance();
	Singleton* sgn2 = Singleton ::Instance();
	cout<<"Now destroy a instance"<<endl;
	return 0;
}

运行结果如下：

可以看出程序并不是先输出主函数中“Now get a instance”，而是先输出“创建了一个单例对象”，在加载单例类的时候这个实例就被创建好了，调用了2个Instance来获取实例对象，只创建了一个实例对象，因此符合单例模式的要求。

上面定义了一个实例对象，它是一个类对象，将这个类对象改为类指针

class Singleton
{
private:
	Singleton();
	Singleton(const Singleton&);
	Singleton& operator=(const Singleton&);
	~Singleton();
	static Singleton *_instance;//定义一个实例对象，它是一个类对象的指针
public:
	static Singleton* Instance();
};

Singleton :: Singleton()
{
	cout << "创建了一个单例对象" << endl; 
}

Singleton :: ~Singleton()
{
	cout << "销毁了一个单例对象" << endl; 
}

Singleton* Singleton :: _instance=new Singleton(); 

Singleton* Singleton :: Instance()
{
	return _instance;
}

int main()
{
	cout<<"Now get a instance"<<endl;
	Singleton* sgn1 = Singleton ::Instance();
	Singleton* sgn2 = Singleton ::Instance();
	cout<<"Now destroy a instance"<<endl;
	return 0;
}

运行结果如下：

没有调用析构函数释放内存，导致内存泄漏，因为此时的全局数据区中存储的是一个实例对象的指针，真正的实例对象存储在堆中，需要调用delete去释放资源。

方法一：在类中写一个释放资源的方法

class Singleton
{
private:
	Singleton();
	Singleton(const Singleton&);
	Singleton& operator=(const Singleton&);
	~Singleton();
	static Singleton *_instance;//定义一个单例对象，它是一个类对象指针
public:
	static Singleton* Instance();
	static void deleteInstance();//销毁实例对象
};

Singleton :: Singleton()
{
	cout << "创建了一个单例对象" << endl; 
}

Singleton :: ~Singleton()
{
	cout << "销毁了一个单例对象" << endl; 
}

Singleton* Singleton :: _instance=new Singleton(); 

Singleton* Singleton :: Instance()
{
	return _instance;
}

void Singleton ::deleteInstance()
{
	delete _instance;
}

int main()
{
	cout<<"Now get a instance"<<endl;
	Singleton* sgn1 = Singleton ::Instance();
	Singleton* sgn2 = Singleton ::Instance();
	cout<<"Now destroy a instance"<<endl;
	Singleton :: deleteInstance();
	return 0;
}

运行结果如下：

方法二：定义一个内部类

class Singleton
{
private:
	Singleton();
	Singleton(const Singleton&);
	Singleton& operator=(const Singleton&);
	~Singleton();
	static Singleton *_instance;//定义一个单例对象，它是一个类对象指针
public:
	static Singleton* Instance();
private:
	class Des
	{
	public:
		Des(){}
		~Des()
		{
			if(_instance != NULL)
			{
				delete _instance;
				_instance = NULL;
			}
		}
	};
	static Des des;
};

Singleton :: Singleton()
{
	cout << "创建了一个单例对象" << endl; 
}

Singleton :: ~Singleton()
{
	cout << "销毁了一个单例对象" << endl; 
}

Singleton* Singleton :: _instance=new Singleton(); 
Singleton ::Des Singleton::des;//初始化一个销毁资源的静态成员变量

Singleton* Singleton :: Instance()
{
	return _instance;
}


int main()
{
	cout<<"Now get a instance"<<endl;
	Singleton* sgn1 = Singleton ::Instance();
	Singleton* sgn2 = Singleton ::Instance();
	cout<<"Now destroy a instance"<<endl;
	return 0;
}

参考文章：https://blog.csdn.net/lvyibin890/article/details/81943637