C++设计模式——单例模式

单例模式
单例模式，可以说设计模式中最常应用的一种模式了，据说也是面试官最喜欢的题目。但是如果没有学过设计模式的人，可能不会想到要去应用单例模式，面对单例模式适用的情况，可能会优先考虑使用全局或者静态变量的方式，这样比较简单，也是没学过设计模式的人所能想到的最简单的方式了。

一般情况下，我们建立的一些类是属于工具性质的，基本不用存储太多的跟自身有关的数据，在这种情况下，每次都去new一个对象，即增加了开销，也使得代码更加臃肿。其实，我们只需要一个实例对象就可以。如果采用全局或者静态变量的方式，会影响封装性，难以保证别的代码不会对全局变量造成影响。

考虑到这些需要，我们将默认的构造函数声明为私有的，这样就不会被外部所new了，甚至可以将析构函数也声明为私有的，这样就只有自己能够删除自己了。在Java和C#这样纯的面向对象的语言中，单例模式非常好实现，直接就可以在静态区初始化instance，然后通过getInstance返回，这种就被称为饿汉式单例类。也有些写法是在getInstance中new instance然后返回，这种就被称为懒汉式单例类，但这涉及到第一次getInstance的一个判断问题。

下面的代码只是表示一下，跟具体哪种语言没有关系。

单线程中：

Singleton* getInstance()
{
    if (instance == NULL)
        instance = new Singleton();
 
    return instance;
}

这样就可以了，保证只取得了一个实例。但是在多线程的环境下却不行了，因为很可能两个线程同时运行到if (instance == NULL)这一句，导致可能会产生两个实例。于是就要在代码中加锁。

Singleton* getInstance()
{
    lock();
    if (instance == NULL)
    {
       instance = new Singleton();
    }
    unlock();

    return instance;
}

但这样写的话，会稍稍映像性能，因为每次判断是否为空都需要被锁定，如果有很多线程的话，就爱会造成大量线程的阻塞。于是大神们又想出了双重锁定。

Singleton* getInstance()
{
    if (instance == NULL)
    {
	lock();
    	if (instance == NULL)
    	{
       		instance = new Singleton();
    	}
    	unlock();
    }

    return instance;
}

这样只够极低的几率下，通过越过了if (instance == NULL)的线程才会有进入锁定临界区的可能性，这种几率还是比较低的，不会阻塞太多的线程，但为了防止一个线程进入临界区创建实例，另外的线程也进去临界区创建实例，又加上了一道防御if (instance == NULL)，这样就确保不会重复创建了。

常用的场景
单例模式常常与工厂模式结合使用，因为工厂只需要创建产品实例就可以了，在多线程的环境下也不会造成任何的冲突，因此只需要一个工厂实例就可以了。

优点
1.减少了时间和空间的开销（new实例的开销）。

2.提高了封装性，使得外部不易改动实例。

缺点
1.懒汉式是以时间换空间的方式。

2.饿汉式是以空间换时间的方式。

#define  _CRT_SECURE_NO_WARNINGS 
#include <iostream>

using namespace std;

/*
class A
{
public:
private:
	A() {

	}
};
*/

/*
一是某个类只能有一个实例；
二是它必须自行创建这个实例；
三是它必须自行向整个系统提供这个实例。
*/

/*
单例模式的使用步骤：
a)	 构造函数私有化。// 为不让在类的外部再创建一个本类的实例
b)	 提供一个全局的静态方法（全局访问点）来获取单例对象。
c)	 在类中定义一个静态指针，指向本类的变量的静态变量指针 。
*/


class Singleton
{
public:

	static Singleton* getInstance()
	{
		return instance;
	}

private:
	//不让类的外部再创建实例
	Singleton() {

	}
	static Singleton* instance;//指向本类唯一实例的指针。
};

/*
饿汉式  - 在编译期间就已经确定这个唯一的实例了。
*/
Singleton*  Singleton::instance = new Singleton; //类的内部


class Singleton2
{
public:
	static Singleton2* getInstance()
 	{
  		//加锁
		if (instance == NULL) {
			instance = new Singleton2;
		}
		//关锁
		return instance;
 	}

private:
	Singleton2() {

	}
	static Singleton2 * instance;
};


//懒汉式的初始化方式
Singleton2 *Singleton2::instance = NULL;


int main(void)
{
	Singleton * s1 = Singleton::getInstance();
	Singleton *s2 = Singleton::getInstance();

	if (s1 == s2) {
		cout << "s1 == s2" << endl;
	}
	else {
		cout << "s1 != s2 " << endl;
	}

	Singleton2 *s3 = Singleton2::getInstance();
	Singleton2 *s4 = Singleton2::getInstance();

	if (s3 == s4) {
		cout << "s3 == s4" << endl;

	}
	else {
		cout << "s3 != s4" << endl;
	}
	
	return 0;
}

单例模式——打印机练习

#define  _CRT_SECURE_NO_WARNINGS 
#include <iostream>
#include <string>

using namespace std;

class Printer
{
public:
	static Printer *getInstance() {
		return instance;
	}

	void print(string text)
	{
		cout << "打印的内容是" << text << endl;
		sequence++;
		cout << "今天已经打印了 " << sequence << "条数据" << endl;
	}

	static int getCnt() {
		return sequence;
	}

private:
	Printer() {

	}

	//垃圾回收工
	class Garbo {
	private:
		~Garbo() {
			if (instance != NULL) {
				delete instance;
			}
		}
	};

	static Garbo garbo; //在静态区域开辟一个对象， garbo
	static int sequence; //记录打印机已经打印了多少条数据。
	static Printer* instance;
};

int Printer::sequence = 0;
Printer* Printer::instance = new Printer;
Printer::Garbo  Printer::garbo;
  

int main(void)
{
	//员工1  获取
	Printer *p1 = Printer::getInstance();//获取到唯一的打印机实例
	p1->print("一份简历");

	Printer *p2 = Printer::getInstance();
	p2->print("lol 皮肤");

	Printer *p3 = Printer::getInstance();
	p3->print("离职申请");
	
	return 0;
}