C++ 特殊类的设计(单例模式)

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

实现方法：

1. 将类的构造私有，拷贝构造声明成私有。防止别人调用拷贝在栈上生成对象。
2. 提供一个静态的成员函数，在该静态成员函数中完成堆对象的创建

class HeapOnly
{
public:
	//在堆上创建对象
	static HeapOnly* HeapCreate()
	{
		return new HeapOnly;
	}

private:
	//构造函数私有
	HeapOnly()
	{}

	//防拷贝
	HeapOnly(const HeapOnly&) = delete;
};

构造函数私有：若不将构造函数私有，调用构造函数也可以在栈上创建对象
防拷贝：是因为拷贝是在栈上进行

2.请设计一个类，只能在栈上创建对象

实现方法：

方法一：同上将构造函数私有化，然后设计静态方法创建对象返回即可。

class StackOnly
{
public:
	static StackOnly CreateObj()
	{
		return StackOnly();
	}
private:
	//构造函数私有
	StackOnly()
	{}
};

方法二：屏蔽new。 因为new在底层调用void* operator new(size_t size)函数，只需将该函数屏蔽掉即可。new屏蔽掉，delete也要屏蔽掉。

class StackOnly
{
public:
	StackOnly()
	{}
private:
	void* operator new(size_t size) = delete;
	void operator delete(void *p) = delete;
};

3.设计一个类，不能被拷贝

拷贝只会发生在两个场景中：拷贝构造函数以及赋值运算符重载，因此想要让一个类禁止拷贝，只需让该类不能调用拷贝构造函数以及赋值运算符重载即可。

• c++98
  将拷贝构造函数与赋值运算符重载只声明不定义，并且将其访问权限设置为私有即可。

class CopyBan
{
 // ...
 
private:
 CopyBan(const CopyBan&);
 CopyBan& operator=(const CopyBan&);
 //...
};

原因：

1. 设置成私有：如果只声明没有设置成private，用户自己如果在类外定义了，就可以不能禁止拷贝了
2. 只声明不定义：不定义是因为该函数根本不会调用，定义了其实也没有什么意义，不写反而还简单，而且如果定义了就不会防止成员函数内部拷贝了。

• C++11
  C++11扩展delete的用法，delete除了释放new申请的资源外，如果在默认成员函数后跟上=delete，表示让编译器删除掉该默认成员函数。

class CopyBan
{
 // ...
 CopyBan(const CopyBan&)=delete;
 CopyBan& operator=(const CopyBan&)=delete;
 //...
};

4.请设计一个类，不能被继承

• c++98
  在c++98中构造函数私有化，派生类继承基类，会调用基类的构造函数，若基类的构造函数无法调用，就无法继承。

class NonIn
{
public:
	static NonIn CreateObj()
	{
		return NonIn();
	}
private:
	NonIn()
	{}
};

示例：

• C++11 final关键字，final修饰类，表示该类不能被继承。

class NonIn final
{
public:
	NonIn()
	{
		cout << "NonIn" << endl;
	}
};

示例：

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

设计模式：

设计模式（Design Pattern）是一套被反复使用、多数人知晓的、经过分类的、代码设计经验的总结。

使用设计模式的目的：为了代码可重用性、让代码更容易被他人理解、保证代码可靠性。

单例模式：

一个类只能创建一个对象，即单例模式，该模式可以保证系统中该类只有一个实例，并提供一个访问它的全局访问点，该实例被所有程序模块共享。

单例模式有两种实现方式：

1.饿汉模式：就是说不管你将来用不用，程序启动时就创建一个唯一的实例对象。

实现方法：

1. 构造函数私有，因为只能创建一个实例
2. 公有的获取对象方法，通过static静态成员函数，获取已经创建好的对象的地址
3. 防拷贝
4. 创建的唯一一个对象是static类型，一方面是静态变量在启动主函数之前就已经创建好；另一方面，如果唯一对象是普通成员，不能在类中构造自己，因为这样就不能知道类的大小了，类中包含自己，就构成无限循环，若是static类型就可以，因为static放在静态区中，不属于类的大小。
   

具体实现

class SingleIeton
{
public:
	
	//公有的获取方法
	static SingleIeton* getObj()
	{
		return &sigle;
	}

private:

	//构造函数私有化
	SingleIeton()
	{}

	//防拷贝
	SingleIeton(const SingleIeton&) = delete;
	SingleIeton& operator=(const SingleIeton&) = delete;

	static SingleIeton sigle;
};
SingleIeton SingleIeton::sigle;

饿汉模式优缺点：

优点：

• 线程安全
• 在类加载的同时已经创建好一个静态对象，调用时反应速度快

缺点：

• 可能会导致进程启动慢，且如果有多个单例类对象实例启动顺序不确定。

2.懒汉模式

如果单例对象构造十分耗时或者占用很多资源，比如加载插件啊， 初始化网络连接啊，读取文件啊等等，而有可能该对象程序运行时不会用到，那么也要在程序一开始就进行初始化，就会导致程序启动时非常的缓慢。 所以这种情况使用懒汉模式（延迟加载） 更好。

实现方法：

1. 构造函数私有
2. 防拷贝
3. 公有的方法获取对象。在类中设置一个指针，调用方法获取对象时，若指针为空，说明之前没有创建过对象，则创建对象；若指针不为空，则直接返回已创建的对象地址。类中的指针是static类型，static变量在程序运行之前就会初始化好；若不是static成员变量，成员变量的初始化是在构造函数的初始化列表中，而判断有没有创建对象时，成员变量指针还没有初始化，还是一堆乱码，所以不能使用成员变量指针。

具体实现：

class SingleIeton
{
public:

	static SingleIeton* getObj()
	{
		if (single == nullptr)
		{
			single = new SingleIeton;
		}
		return single;
	}

private:
	//构造函数私有化
	SingleIeton()
	{}

	//防拷贝
	SingleIeton(const SingleIeton&) = delete;
	SingleIeton& operator=(const SingleIeton&) = delete;

	static SingleIeton* single;
};
SingleIeton* SingleIeton::single = nullptr;

上面代码存在线程安全问题，若多个线程同时进入if (single == nullptr)语句中，就会创建多个对象，而single只能保存最后一次创建的对象地址，前面创建的对象都丢失了，所以判断指针是否为空之前需要加锁保护。

static SingleIeton* getObj()
	{
		_mutex.lock();
		if (single == nullptr)
		{
			single = new SingleIeton;
		}
		_mutex.unlock();
		return single;
	}

加锁的开销是比较大的，这样每次获取对象时都需要进行加锁，开销就更大了。
在这里我们使用双重判断，若对象已经创建了，就直接返回对象的地址；若没有创建(single==nullptr)，则再去加锁，创建对象。

class SingleIeton
{
public:

	static SingleIeton* getObj()
	{
		if (single == nullptr)
		{
			_mutex.lock();
			if (single == nullptr)
			{
				single = new SingleIeton;
			}
			_mutex.unlock();
		}
		return single;
	}

private:
	//构造函数私有化
	SingleIeton()
	{}

	//防拷贝
	SingleIeton(const SingleIeton&) = delete;
	SingleIeton& operator=(const SingleIeton&) = delete;

	static SingleIeton* single;
	static mutex _mutex;
};
SingleIeton* SingleIeton::single = nullptr;
mutex SingleIeton::_mutex;