C++特殊类的设计

设计一个类不能被拷贝

拷贝一个类对象可以有两种方式,分别是拷贝构造和赋值运算符重载函数,因此要想一个类不能被拷贝，只需在这两个函数上做文章就可以了。
1.只声明不定义（因为定义也没啥意义，反正也不会调用该函数），且设为私有函数
为什么要设为私有函数呢？
如果只声明为public的，可能用户会自己在类外进行定义实现，那么这个类就变得可以被拷贝了。

private:
	A(const A& a)
	{

	}

	A& operator=(const A& a)
	{

	}

2.把这两个函数给禁掉（C++11）

A(const A& a) = delete;
A& operator=(const A& a) = delete;

C++11中，通过关键字delete来禁用函数，如果在一个函数后面加上=delete就表示删除该默认成员函数

请设计一个类，只能在堆上创建对象

提供一个静态成员函数，该函数完成对象在堆上的创建，把构造函数设为私有，并把该类的拷贝构造函数和赋值运算符重载函数设成私有或者禁掉，防止别人调用在栈上生成对象。

class HeapOnly
{
public:
	static HeapOnly* CreatObject()
	{
		return new HeapOnly();
	}

private:
	HeapOnly()
	{

	}

	HeapOnly(const HeapOnly& hp) = delete;
	HeapOnly& operator=(const HeapOnly& hp) = delete;

};

这里为什么要把CreatObject设为static呢？
因为我们的返回值是new HeapOnly()创建这个对象，而如果不加static的话就需要先有HeapOnly()这个对象，才能去调用这个函数，而加了static修饰这个函数之后，这个函数就变成了属于属于这个类的了而不是这个对象的了，从而可以通过类去调用这个函数了

设计一个类只能在栈上去创建对象

通过静态成员函数去调用构造函数去创建对象，并把new和delete关键字给禁掉

class StackOnly
{
public:
	static StackOnly GetInstance()
	{
		return StackOnly();
	}

	void* operator new(size_t size) = delete;
 	void operator delete(void* p) = delete;
	
private:
	StackOnly()
		:_a(0)
	{

	}
	int _a;
};

设计一个类不能被继承

方法一：把基类的构造函数私有化

#include <iostream>

using namespace std;

class NonInherit
{
public:
	static NonInherit GetInstance()
	{
		return NonInherit();
	}

private:
	NonInherit()
	{

	}
};

class A : public NonInherit
{
private:
	int _a;
};

方法二：使用C++11关键字final进行修饰

#include <iostream>

using namespace std;

class NonInherit final
{
};

class A : public NonInherit
{
};

设计一个类，只能创建一个对象(单例模式)

**单例模式：一个类只能创建一个对象，即单例模式，该模式可以保证系统中只有一个实例，并提供一个访问他的全局访问点，该实例被所有程序模块共享。**比如在某个服务器程序中，该服务器的配置信息存放在一个文件中，这些配置数据由一个单例对象统一读取，然后服务进程中的其他对象再通过这个单例对象获取这些配置信息，这种方式简化了在复杂环境下的配置管理。

饿汉模式

#include <iostream>

using namespace std;

class Singleton
{
public: 
	static Singleton& GetInstance()
	{
		return _instance;
	}

private:
	Singleton()
	{
		cout << "Singleton()" << endl;
	}

	Singleton(const Singleton& _instance) = delete;
	Singleton& operator=(const Singleton& instance) = delete;

	static Singleton _instance;
};

Singleton Singleton::_instance;
int main()
{
	/* Singleton a;
	 Singleton b;*/
	
	cout << &Singleton::GetInstance()<< endl;
	cout << &Singleton::GetInstance() << endl;

	return 0;
}

类中的静态成员变量_instance是就是这个类对象，它是属于这个类的，且在函数体外进行了定义，所以在进入main函数之前该成员变量就被创建了。且在进入main函数之后，如果想再创建对象就必须调用类中的静态成员函数，而该函数返回的对象就是我们进入main函数之前创建的那个静态成员变量_instance，所以保证了每一次的得到的对象都是同一个。因为构造函数被私有，在后续创建对象时我们通过GetInstance()来创建对象时，不会调用构造函数，而是直接返回成员变量_instance

Singleton()
{
	cout << "Singleton()" << endl;
}

在进入main函数之前这句话就打印了，进入main函数之后创建对象时，因为不会在调用搞糟函数，所以这句话不会再被打印

饿汉模式缺点：如果类之间有依赖关系，或者占用空间过大就会导致启动速度减慢，需要花较长的时间才能进入main函数

懒汉模式

为什么叫懒汉模式？
因为该对象会在进入main函数之后，当你手动去创建时才会创建，而且在第一次之后创建的对象都与第一个是同一个
这里通过一个静态成员对象指针变量来控制，创建的是同一个，先给这个对象指针赋值为nullptr，当它为nullptr时，才给你创建对象，并把所创建对象的地址给静态成员变量指针，当不为nullptr时，你调用成员函数GetInstance()得到的是这个静态成员对象指针的解引用，也就是第一一次创建的对象的地址

#include <iostream>

using namespace std;

class Singleton
{
public:
	static Singleton& GetInstance()
	{
		if (_instance == nullptr)
		{
			_instance = new Singleton;
			return *_instance;
		}
		return *_instance;
	}

	Singleton(const Singleton& sl) = delete;
	Singleton operator=(const Singleton& sl) = delete;

private:
	Singleton()
	{

	}

	static Singleton* _instance;//单例对象指针
};

Singleton* Singleton::_instance = nullptr;

int main()
{
	cout << &Singleton::GetInstance() << endl;
	cout << &Singleton::GetInstance() << endl;
	//错误	C2280	“Singleton::Singleton(const Singleton&)”: 尝试引用已删除的函数
	//Singleton s = Singleton::GetInstance();
	return 0;
}

单例模式总结

饿汉模式

不管你将来是不是用这个实例对象，只要程序启动这个对象就被实例化出来，且全局始终只有这一个实例化对象。
优点：简单
缺点：可能会导致进程启动变慢，且如果有多个单例类对象实例，启动顺序不确定。如果这个单例对象在多线程高并发情况下频繁使用，性能要求较高，那么显然使用饿汉模式来避免资源竞争，提高响应速度更好。

懒汉模式

如果单例对象构造十分耗时或者占用资源，比如加载组件，初始化网络链接，读取文件等，且有可能这个对象在该程序运行时并不会被用到，那么在程序启动前就进行初始化就会导致程序启动非常缓慢，所以这种情况下，选用懒汉模式（延时加载）更好。