特殊类设计

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

只能在堆上创建对象，也就是只能通过new操作符创建对象，方式如下：

• 将构造函数设置为私有，防止外部直接调用构造函数在栈上创建对象

• 向外部提供一个获取对象的static接口，该接口在堆上创建一个对象并返回

• 将拷贝构造函数设置为私有，并且只声明不实现，防止外部调用拷贝构造函数在栈上创建对象

class HeapOnly
{
public:
	//2.提供一个获取对象的接口,并将该接口设置为静态成员函数
	static HeapOnly* CreateObj()
	{
		return new HeapOnly;
	}
private:
	//1.将构造函数私有化
	HeapOnly()
	{}
	//3.将拷贝构造函数设置为私有,并且只声明不实现
	HeapOnly(const HeapOnly&);
	//c++11
	HeapOnly(const HeapOnly&) = delete;
};

注意：向外部提供的CreateObj函数必须设置为静态成员函数，因为外部调用该接口就是为了获取对象的，而非静态成员函数必须通过对象才能调用，这就变成鸡生蛋蛋生鸡的问题了

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

方法一

• 将构造函数设置为私有，防止外部直接调用构造函数在堆上创建对象
• 向外部提供一个获取对象的static接口，该接口在栈上创建一个对象并返回

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

但该方法有一个缺陷：无法防止外部调用拷贝构造函数创建对象

StackOnly obj1 = StackOnly::CreateObj();
static StackOnly obj2(obj1); //在静态区拷贝构造对象
StackOnly* ptr = new StackOnly(obj1); //在堆上拷贝构造对象

方法二

• 屏蔽operator new函数和operator delete函数

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

	//c++11
	/*void* operator new(size_t size) = delete;
	void operator delete(void* p); = delete*/
};

new和delete的原理：

• 第一步是调用operator new函数申请空间，第二步是在申请的空间上执行构造函数，完成对象的初始化工作

• 第一步是在该空间上执行析构函数，完成对象中资源的清理工作，第二步是调用operator delete函数释放对象的空间

new和delete默认调用的是全局的operator new函数和operator delete函数，但如果一个类重载了专属的operator new函数和operator delete函数，那么new和delete就会调用这个专属的函数。所以只要把operator new函数和operator delete函数屏蔽掉，那么就无法再使用new在堆上创建对象

但该方法也有一个缺陷，就是无法防止外部在静态区创建对象

static StackOnly obj; //在静态区创建对象

当然，也可以将方法一和方法二进行结合，结合之后就只是无法防止在静态区拷贝构造对象

请设计一个类，不能被拷贝

要让一个类不能被拷贝，就要让该类不能调用拷贝构造函数和赋值运算符重载函数，因此直接将该类的拷贝构造函数和赋值运算符重载函数设置为私有，或者用C++11的方式将这两个函数删除

class NoCopy
{
public:
	NoCopy()
	{}
private:
	NoCopy(const NoCopy&);
	NoCopy& operator=(const NoCopy&);

	//c++11
	/*NoCopy(const NoCopy&) = delete;
	NoCopy& operator=(const NoCopy&) = delete;*/
};

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

方法一

C++98：将该类的构造函数设置为私有即可，因为子类的构造函数被调用时，必须调用父类的构造函数初始化父类的那一部分成员，但父类的私有成员在子类当中是不可见的，所以在创建子类对象时子类无法调用父类的构造函数对父类的成员进行初始化，因此该类被继承后子类无法创建出对象

class NonInherit
{
public:
	static NonInherit CreateObj()
	{
		return NonInherit();
	}
private:
	//将构造函数设置为私有
	NonInherit()
	{}
};

方法二

C++11：C++98的这种方式其实不够彻底，因为这个类仍然可以被继承（编译器不会报错），只不过被继承后无法实例化出对象而已。于是C++11中提供了final关键字，被final修饰的类叫做最终类，最终类无法被继承，此时就算继承后没有创建对象也会编译出错

class NonInherit final
{
	//...
};

请设计一个类，只能创建一个对象（单例模式）

什么是单例模式

• 单例模式是一种设计模式（Design Pattern），设计模式就是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式的目的就是为了可重用代码、让代码更容易被他人理解、保证代码可靠性程序的重用性

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

• 比如在某个服务器程序中，该服务器的配置信息存放在一个文件中，这些配置数据由一个单例对象同一读取，然后服务进程中的其他对象再通过这个单例对象获取这些配置信息，这种方式简化了在复杂环境下的配置管理

饿汉实现方式

• 将构造函数设置为私有，并将拷贝构造函数和赋值运算符重载函数设置为私有或删除，防止外部创建或拷贝对象
• 提供一个指向单例对象的static指针，并在程序入口之前完成单例对象的初始化
• 提供一个全局访问点获取单例对象

class Singleton
{
public:
	//3、提供一个全局访问点获取单例对象
	static Singleton* GetInstance()
	{
		return _inst;
	}
private:
	//1、将构造函数设置为私有，并防拷贝
	Singleton()
	{}
	Singleton(const Singleton&) = delete;
	Singleton& operator=(const Singleton&) = delete;
	//2、提供一个指向单例对象的static指针
	static Singleton* _inst;
};

//在程序入口之前完成单例对象的初始化
Singleton* Singleton::_inst = new Singleton;

懒汉实现方式

• 将构造函数设置为私有，并将拷贝构造函数和赋值运算符重载函数设置为私有或删除，防止外部创建或拷贝对象
• 提供一个指向单例对象的static指针，并在程序入口之前先将其初始化为空
• 提供一个全局访问点获取单例对象

class Singleton
{
public:
	//3、提供一个全局访问点获取单例对象
	static Singleton* GetInstance()
	{
		//双检查
		if (_inst == nullptr)
		{
			_mtx.lock();
			if (_inst == nullptr)
			{
				_inst = new Singleton;
			}
			_mtx.unlock();
		}
		return _inst;
	}
private:
	//1、将构造函数设置为私有，并防拷贝
	Singleton()
	{}
	Singleton(const Singleton&) = delete;
	Singleton& operator=(const Singleton&) = delete;
	//2、提供一个指向单例对象的static指针
	static Singleton* _inst;
	static std::mutex _mtx; //互斥锁
};

//在程序入口之前先将static指针初始化为空
Singleton* Singleton::_inst = nullptr;
std::mutex Singleton::_mtx; //初始化互斥锁

线程安全相关问题：

• 懒汉模式在程序运行之前没有进行单例对象的创建，而是等到某个线程需要使用这个单例对象时再进行创建，也就是GetInstance函数第一次被调用时创建单例对象

• 因此在调用GetInstance函数获取单例对象时，需要先判断这个static指针是否为空，如果为空则说明这个单例对象还没有创建，此时需要先创建这个单例对象然后再将单例对象返回

• GetInstance函数第一次调用时需要对static指针进行写入操作，这个过程不是线程安全的，因为多个线程可能同时调用GetInstance函数，如果不对这个过程进行保护，此时这多个线程就会各自创建出一个对象

双检查加锁：

对GetInstance函数中创建单例对象的过程进行保护，本质就是需要引入互斥锁，最简单的加锁方式就是在进行if判断之前加锁，在整个if语句之后进行解锁

但实际只有GetInstance函数第一次被调用，创建单例对象时需要使用互斥锁进行保护，而后续调用GetInstance函数获取单例对象只是一个读操作，是不需要使用互斥锁进行保护的

如果简单的将加锁解锁操作放到if语句前后，那么在后续调用GetInstance函数获取已经创建好的单例对象时，就会进行大量无意义的加锁解锁操作，导致线程不断切入切出，进而影响程序运行效率。对于这种只有第一次需要加锁保护的场景可以使用双检查加锁，双检查就是在当前加锁和解锁的外面再进行一次if判断，判断static指针是否为空

这样一来，后续调用GetInstance函数获取已经创建好的单例对象时，外层新加的if判断就会起作用，这样就避免了后续无意义的加锁解锁操作

饿汉模式和懒汉模式对比

维度	饿汉模式	懒汉模式
线程安全	天生安全，无需额外处理	需同步机制保证安全
资源占用	可能浪费内存，提前加载实例	按需加载，节省内存
首次调用速度	直接返回实例，速度快	需初始化实例，可能有延迟
实现复杂度	简单，代码直观	复杂，需处理多线程问题

懒汉模式还有一种比较经典的实现方式：

• 将构造函数设置为私有，并将拷贝构造函数和赋值运算符重载函数设置为私有或删除，防止外部创建或拷贝对象
• 提供一个全局访问点获取单例对象

class Singleton
{
public:
	//2、提供一个全局访问点获取单例对象
	static Singleton* GetInstance()
	{
		static Singleton inst;
		return &inst;
	}
private:
	//1、将构造函数设置为私有，并防拷贝
	Singleton()
	{}
	Singleton(const Singleton&) = delete;
	Singleton& operator=(const Singleton&) = delete;
};

在单例类的GetInstance函数中定义一个静态的单例对象并返回。

• 由于实际只有第一次调用GetInstance函数时才会定义这个静态的单例对象，这也就保证了全局只有这一个唯一实例

• 并且这里单例对象的定义过程是线程安全的，因为现在的C++标准保证多线程初始化static变量不会发生数据竞争，可以视为原子操作

• 该方法属于懒汉模式，因为局部静态变量不是在程序运行主函数之前初始化的，而是在第一次调用GetInstance函数时初始化的

这种版本的懒汉主要有如下两个缺点：

• 单例对象定义在静态区，因此太大的单例对象不适合使用这种方式。

• 单例对象创建在静态区后没办法主动释放

单例对象的释放

单例对象创建后一般在整个程序运行期间都可能会使用，所以我们可以不考虑单例对象的释放，程序正常结束时会自动将资源归还给操作系统。

如果要考虑单例对象的释放，可以参考以下两种方式：

在单例类中编写一个DelInstance函数，在该函数中进行单例对象的释放动作，当不再需要该单例对象时就可以主动调用DelInstance释放单例对象

static void DelInstance()
{
	_mtx.lock();
	if (_inst != nullptr)
	{
		delete _inst;
		_inst = nullptr;
	}
	_mtx.unlock();
}

在单例类中实现一个内嵌的垃圾回收类，在垃圾回收类的析构函数中完成单例对象的释放。在单例类中定义一个静态的垃圾回收类对象，当该对象被消耗时就会调用其析构函数，这时便对单例对象进行了回收

//垃圾回收类
class CGarbo
{
public:
	~CGarbo()
	{
		if (_inst != nullptr)
		{
			delete _inst;
			_inst = nullptr;
		}
	}
};