单例模式笔记

平时做项目，学习的过程中没有怎么接触过设计模式（统统在面向过程。。。很是菜），单例模式以前都不清楚，为了应对面试中可能出现的情况，至少还是要扒一扒单例的裤子。

什么是单例以及单例的构造方式

单例模式，就是只允许产生一个实例化对象，即这个类只有一个对象（不允许重婚哦）。
一般情况下，我们实现一个对象的实例化，会进行普通的构造或者利用new一个堆对象。想要实现单例，显然需要限制构造函数的访问权限-private。然后暴露一个接口给用户进行实例化。如下：

class Student {
public:
	~Student() {
		cout << "deconstructor" << endl;
	}

	////通过一个接口实现实例化
	//static Student* CreatObj() {
	//	if (m_obj == nullptr)
	//	{
	//		m_obj = new Student();
	//	}
	//	return m_obj;

private:
	Student() {//构造函数私有化进行限制
		cout << "constructor" << endl;
	}
	static Student* m_obj;//类外初始化`在这里插入代码片`
};

int main() {
	Student* s1 = Student::CreatObj();//没有析构，需要手动delete
	Student* s2 = Student::CreatObj();*/


	return 0;
}

但是此时并没有真正实现单例，因为我们没调用一次CreatObj就会new一次，实际上还是可以实例化多个不同的对象。且此时需要手动释放（析构），很不友好。所以上述的私有构造中，我们先对对象指针进行判断，如果指针为空，说明没有实例化过，进行实例化；否则，不再new，直接返回一个对象指针。
注意为什么构造的接口方法和对象指针需要加static?如果不加static，再调用构造结构时，需要有一个对象，这就成立先有鸡还是先有蛋的问题，因此方法加上static，使其生命周期延长。对象指针同理。
此时无论调用多少次CreatObj，都只会有一个对象，所有new出来的指针都指向头一个空间。
OK，这是单例的构造方式。是否有遗漏呢？答案是肯定的。

单例下限制拷贝构造

来看以下这种情况，注意main中，我们通过Student s3 = Student::CreatObj();实例了一个对象，输出如下，调用两次析构，说明我们有两个对象。可是很奇怪，构造明明只有一次呀？注意s3的构造方式，=，说明此处是利用默认的拷贝构造函数，先利用调用CrearObj()生成一个临时对象，再复制给s3。因此， 单例模式下，我们不仅仅要限制构造函数，还要限制复制构造函数。

//单例，只产生一个实例
class Student {
public:
	~Student() {
		cout << "deconstructor" << endl;
	}

	////通过一个接口实现实例化
	//static Student* CreatObj() {
	//	if (m_obj == nullptr)
	//	{
	//		m_obj = new Student();
	//	}
	//	return m_obj;

	//	//return new Student();//此时，需要一个对象才能调用这个接口，先有鸡还是蛋的问题,需要静态
	//}

	static Student& CreatObj() {
		static Student obj;//不用new，使用构造

		return obj;
	}

private:
	Student() {//构造函数私有化进行限制
		cout << "constructor" << endl;
	}
	static Student* m_obj;//类外初始化
};
Student* Student::m_obj = nullptr;

int main() {
	Student& s1 = Student::CreatObj();
	//Student& s2 = Student::CreatObj()；	
	Student s3 = Student::CreatObj();
	return 0;
}

如何限制？同理，私有化复制构造。

private:
	Student() {//构造函数私有化进行限制
		cout << "constructor" << endl;
	}

	Student(Student& obj) {//copyconstructor私有化限制
		printf("copy constructor");
	}

	static Student* m_obj;//类外初始化

另一种写法，是禁止编译器产生拷贝构造

public:
	Student(Student& obj) = delete;
	Student* operator=(Student& obj)=delete;

得到单例模式如下

#include<iostream>

using namespace std;


//单例，只产生一个实例
class Student {
public:
	~Student() {
		cout << "deconstructor" << endl;
	}

	////通过一个接口实现实例化
	//static Student* CreatObj() {
	//	if (m_obj == nullptr)
	//	{
	//		m_obj = new Student();
	//	}
	//	return m_obj;

	//	//return new Student();//此时，需要一个对象才能调用这个接口，先有鸡还是蛋的问题,需要静态
	//}

	static Student& CreatObj() {
		static Student obj;//不用new，使用构造

		return obj;
	}

	Student(Student& obj) = delete;
	Student* operator=(Student& obj)=delete;

private:
	Student() {//构造函数私有化进行限制
		cout << "constructor" << endl;
	}

	static Student* m_obj;//类外初始化
};

Student* Student::m_obj = nullptr;

int main() {
	Student& s1 = Student::CreatObj();
	//Student s3 = Student::CreatObj();

	return 0;
}