单例模式定义

该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。

在C++中，我个人的理解是，不需要自己new类指针，这样一方面也方便程序员自己管理内存，另一方面可以节省系统指针，减少占用内存资源。

单例模式的实现要求

简单的来说，就是一个类要有唯一的单例，而且这个单例类能够被其他对象所调用，不能用，那就没意义了嘛。

单例模式的代码实现

前面两个定义和实现要求理解之后，让我们来看看单例模式是如何在C++中被巧妙地利用。

首先看一下使用单例模式的类

头文件单例类的定义如下：

//单例模式类
class Singleton
{
public:
	Singleton();
	~Singleton();
	void walk();

	static Singleton * getSingleton(); //返回单例指针
private:
	static Singleton * m_Instance;//单例全局指针

	//程序结束时释放静态成员
	class CGararge // 它的唯一工作就是在析构函数中删除CSingleton的实例  
	{  
	public:  
		~CGararge()  
		{  
			//这边清空单例指针 回收内存
			if (Singleton::m_Instance)  
				delete Singleton::m_Instance;  
		}  
	 };   
	static CGararge Garbo; // 定义一个静态成员，在程序结束时，系统会调用它的析构函数  
};

其中定义了单例成员指针m_Instance或获取单例指针的方式

还定义了类CGarbage 用于释放单例指针

接下来是实现cpp文件

Singleton::Singleton()
{
}

Singleton* Singleton::m_Instance = nullptr;

Singleton::~Singleton()
{
	cout << "被析构了" << endl;
}

void Singleton::walk()
{
	cout << " I AM WALKING ALONE" << endl;
}

Singleton* Singleton::getSingleton()
{
	//如果没被实例化 就先new一个
	if(m_Instance==nullptr)
	{
		m_Instance = new Singleton();
	}
	return m_Instance;
}

这里面很容易看出来 getSingleton()函数用来new单例指针判断是否单例指针存在，这样的好处是可以保证整个类的全局指针只占用一个内存地址，无需每次都要new

接下来看一下测试代码

	Singleton * cur_Instance = Singleton::getSingleton();
	cur_Instance->walk();
	cout << "旧的地址" << cur_Instance << endl;
	Singleton * cur_NextInstance = cur_Instance->getSingleton();
	cur_NextInstance->walk();
	cout << "新的地址"<< cur_NextInstance << endl;
	int mm ;
	cin >> mm;

运行程序：

可以明显的看出，只产生了一个实例指针，这样很方便我们去管理内存，也不占用内存资源

接下来看一下不用单例模式的常规类会有什么不一样

头文件

class People
{
public:
	void walk();
};

定义了一个人的类里面一个walk方法

实现

void People::walk()
{
	cout << " I AM WALKING ALONE" << endl;
}

很简单和上面一样

接下来看一下测试代码

	People *p_people = new People();
	p_people->walk();
	People *p_nextPeople = new People();
	p_nextPeople->walk();
	cout << "旧地址" << p_people << endl; 
    cout << "新地址" <<  p_nextPeople << endl; 

	delete p_people;
	delete p_nextPeople;

测试代码也很简单

new了两个指针然后执行walk函数最后看一下地址然后释放内存

看一下运行结果：

可以明显看出这个产生了两个内存，如果在大型项目当中需要在不同的文件当中引用类，很明显，对于程序本身占用内存是个负担，而且很容易造成内存泄漏的现象，所以单例模式的优势也显而易见，可以尽可能占用少的内存，并且及其易于管理内存，希望借着两个例子，能够给大家带来一点启发。