【C++高阶(八)】单例模式&特殊类的设计

---

1. 前言

在实际场景中,总会遇见一些特殊情况,
比如设计一个类,只能在堆上开辟空间,
亦或者是设计一个类只能实例化一个对象
在实际需求的场景下,来学习这节实用课

---

2. 设计一个不能被拷贝/继承的类

1. 设计一个不能被拷贝的类

C++11中引入的关键字delete
就能很好的解决这个问题,并且
不仅仅要禁用拷贝,还有赋值!

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

在C+98中,也有方法能够解决,
那就是显示将拷贝构造函数和
赋值运算符重载函数私有化!

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

1. 设计一个不能被继承的类

使用关键字final就能解决问题

class A  final
{
    // ....
};

在C++98中,将构造函数私有化也能
达到目的,因为子类的构造会调用基类
的构造,如果私有了基类的构造就会报错!

class NonInherit
{
private:
	NonInherit()
	{}
};

---

3. 只能在堆上创建对象的类

只能在堆上创建对象的含义就是
必须使用new来创建对象.

1. 将析构函数私有化

//思路一,封析构函数
class HeapOnly
{
public:
	void destory()
	{
		delete this;
	}
private:
	~HeapOnly()
	{
		cout<<"调用析构成功!"<<endl;
	}
};

能否达到目的大家可以自行测试!

1. 将构造函数私有化

//思路二,封构造函数
class HeapOnly
{
public:
	static HeapOnly* CreateObject(int x = 0)
	{
		return new HeapOnly(x);
	}
private:
	HeapOnly(int x = 0):_x(x)
	{}
	int _x;
};

1. 以上两种方案真的就ok了吗?

HeapOnly* ho1 = HeapOnly::CreateObject(10);
HeapOnly ho(*ho1);

所以在上面两种方案的基础上
要禁用拷贝构造和赋值重载两个函数!

---

4. 只能在栈上创建对象的类

有了前面的思想,解决这个类型
的问题就显示很小儿科了!

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

// 禁掉operator new可以把下面用new 调用拷贝构造申请对象给禁掉
// StackOnly obj = StackOnly::CreateObj();
// StackOnly* ptr3 = new StackOnly(obj);
	void* operator new(size_t size) = delete;
	void operator delete(void* p) = delete;
private:
	StackOnly()  
		:_a(0)
	{}
	private:
	int _a;
};

---

5. 只能实例化一个对象的类的介绍

一个类只能实例化一个对象
这就是大名鼎鼎的"单例模式"

---

6. 饿汉模式的具体实现

注意,这里实现的是样例(demo)代码,在
不同的工程场景下需要大家做灵活的变换

// 饿汉模式
// 优点：简单
// 缺点：可能会导致进程启动慢，且如果有多个单例类对象实例启动顺序不确定。
class Singleton
{
public:
	static Singleton* GetInstance()
	{
		return _ins;
	}
private:
	//限制类外随意创建对象
	Singleton(const Singleton& s) = delete;
	Singleton& operator=(const Singleton& s) = delete;
	Singleton()
	{}
private:
	static Singleton* _ins;
};
Singleton* Singleton::_ins = new Singleton;

---

7. 懒汉模式的具体实现

//懒汉模式
class Singleton
{
public:
	static Singleton* GetInstance()
	{
		if (_ins == nullptr)//双检查加锁,只有第一次进来时需要加锁,其他情况不用加锁
		{
			imtx.lock();
			if (_ins == nullptr)//第一次调用才创建实例!
			{
				_ins = new Singleton;
			}
			imtx.unlock();
		}
		
		return _ins;
	}
	void DelInstance()
	{
		imtx.lock();
		if (_ins != nullptr)
		{
			cout << "over!!!" << endl;
			delete _ins;
			_ins = nullptr;
		}
		imtx.unlock();
	}
private:
	//限制类外随意创建对象
	Singleton(const Singleton& s) = delete;
	Singleton& operator=(const Singleton& s) = delete;
	Singleton()
	{}
private:
	static Singleton* _ins;
	static mutex imtx;
};
Singleton* Singleton::_ins = nullptr;
mutex Singleton::imtx;

当然,这两个模式都是样例代码,大家要随机应变

---

8. 总结以及拓展

特殊类的设计这块儿,大家需要在写某些
项目的时候真正运用到它才能体会出它
的作用和奥妙之处,总的来说单例模式是
使用很广泛并且很有用的一种设计模式!

C++常见的11种设计模式

---