【C++】特殊类的设计(单例模式为主)(学习复习兼顾)

꧁ 大家好，我是 兔7 ，一位努力学习C++的博主~ ꧂

☙ 如果文章知识点有错误的地方，请指正！和大家一起学习，一起进步❧

🚀 如有不懂，可以随时向我提问，我会全力讲解~💬

🔥 如果感觉博主的文章还不错的话，希望大家关注、点赞、收藏三连支持一下博主哦~！👀

🔥 你们的支持是我创作的动力！⛅

🧸 我相信现在的努力的艰辛，都是为以后的美好最好的见证！⭐

🧸 人的心态决定姿态！⭐

🚀 本文章CSDN首发！✍

目录

0. 前言

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

​编辑

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

方法一： 同上

方法二：屏蔽new

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

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

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

设计模式：

单例模式：

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

懒汉模式和饿汉模式的对比

饿汉

懒汉

---

0. 前言

        此博客为博主以后复习的资料，所以大家放心学习，总结的很全面，每段代码都给大家发了出来，大家如果有疑问可以尝试去调试。

        大家一定要认真看图，图里的文字都是精华，好多的细节都在图中展示、写出来了，所以大家一定要仔细哦~

        感谢大家对我的支持，感谢大家的喜欢， 兔7 祝大家在学习的路上一路顺利，生活的路上顺心顺意~！

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

实现方式：

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

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

	HeapOnly(const HeapOnly&) = delete;

private:
	HeapOnly()
	{}
	//HeapOnly(const HeapOnly&);
};

//HeapOnly::HeapOnly(const HeapOnly&)
//{}

int main()
{
	//HeapOnly ho;
	//HeapOnly* p = new HeapOnly;
	HeapOnly* p = HeapOnly::CreateObj();
	HeapOnly copy(*p);

	return 0;
}

        我们可以看到，我们这里将构造函数放到 private 里面，那么类外面就不能调用构造函数，也就不能创建对象了，所以我们要想办法在类里设置一个接口可以调用构造函数，但是这个接口必须要是 static 的，因为如果不是静态的，那么类外必须要用实例化好的对象去调用，但是我们又不能在类外创建对象，我们调用这个接口就是为了创建对象。

        所以这里就有了一个问题，那么这时就要设置为静态的，这样外面直接就可以调用这个接口在堆上创建对象了。

         但是我们可以看到，虽然我们将构造函数设为私有不可以直接创建对象了，但是还是可以通过拷贝构造函数去在栈上创建对象！

        所以还是老套路嘛，直接将拷贝构造在私有里声明一下就可以了。

当然这里为什么直接声明一下就可以了呢？

        是因为我们没有必要去实现，因为也没有人去用它，所以就实现可以，不实现也是可以的。

那构造函数是需要实现的，不能够只声明又是为什么呢？

        这是因为我们要用构造函数在堆上去创建对象，简单来说就是我们上面的 CreateObj 里要去使用这个构造函数。

        虽然这个拷贝构造虽然没有实现，只是声明了一下，但是还是要将拷贝构造放到私有里面，原因：

        就有人有可能会在类外去定义，那么拷贝构造就又可以使用了，所以做事做绝，直接在私有里去声明就可以了。

        这个方法在 C++98 里叫做防拷贝。

        在 C++11 中还有一种方法，就是用关键字 delete 。

        我们可以看到，这个函数已经被删除了，所以不可以去调用了。而且如果我们将它放到公有里面，还是不可以使用的：

        可以看到，是同样的效果。

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

方法一： 同上

class StackOnly
{
public:
	static StackOnly CreateObject()
	{
		return StackOnly();
	}
private:
	StackOnly()
	{}
};

         还是和上面相同的做法，但是这里就不能禁用拷贝构造了，因为在返回的时候肯定是返回一个局部对象，所以 CreateObject 只能传值返回，但是只要是传值返回就肯定是要拷贝构造，那么如果把拷贝构造禁用了，那么返回的时候就会有问题。

方法二：屏蔽new

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

注意：也要防止定位new 

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

int main()
{
	StackOnly so;
	StackOnly* p = new StackOnly;

	static StackOnly sso;
	return 0;
}

        这里是因为 new 的时候是由两部分构成，第一部分是申请空间调用 operator new ，默认是调用全局的 operator new，再调它的构造函数。但是一个类可以重载专属的 operator new，所以这时肯定就会调用专属的  operator new ，所以我们将 operator new 设为私有，那么这时就调用不动了。

         当然也可以用 C++11 的方法去实现。

        但是这个方法有缺陷，虽然可以在栈上创建对象，不能在堆上创建对象了，但是：

        但是可以在静态区去创建对象，所以这个方法是有一些缺陷的。

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中构造函数私有化，派生类中调不到基类的构造函数。则无法继承。

        无法继承的原因是父类私有成员在子类不可见。

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

        也就是说子类的构造函数想要初始化父类的那一部分，不能自己去对那一部分去初始化，而是要调用父类的构造函数去初始化，所以我们只要将父类的构造函数设为私有的，那么子类就看不到父类的构造函数，也就无法对其初始化，也就不能够被继承。

        但是这里其实还是不够彻底的：

        我们可以看到，其实是可以继承的，但是这里真正限制的是：

        也就是子类继承后不能实例化出对象来，但是其实不能实例化出对象来，这个类就费了一半了，因为我们在使用类的时候基本都是实例化出对象，然后通过对象去进行一番操作。

        但这也是不彻底的，所以才有了 C++11 的一个关键字 final。

• C++11方法

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

        C++11 为了更直观彻底的实现不能被继承，增加了关键字 final。 

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

        在设计单例模式的时候会用到多线程的知识，我已经写过关于多线程的特特特详细博客了，下面就是链接，大家可以去看一看，多线程是非常重要的！

多线程(重中之重)

设计模式：

        设计模式（Design Pattern）是一套被反复使用、多数人知晓的、经过分类的、代码设计经验的总结。为什么会产生设计模式这样的东西呢？就像人类历史发展会产生兵法。最开始部落之间打仗时都是人拼人的对砍。后来春秋战国时期，七国之间经常打仗，就发现打仗也是有套路的，后来孙子就总结出了《孙子兵法》。孙子兵法也是类似。

        使用设计模式的目的：为了代码可重用性、让代码更容易被他人理解、保证代码可靠性。 设计模式使代码编写真正工程化；设计模式是软件工程的基石脉络，如同大厦的结构一样。

单例模式：

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

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

• 饿汉模式

        就是说不管你将来用不用，程序启动时就创建一个唯一的实例对象。

// 饿汉模式
// 优点：简单
// 缺点：可能会导致进程启动慢，且如果有多个单例类对象实例启动顺序不确定。
class Singleton
{
public:
	static Singleton* GetInstance()
	{
		return m_instance;
	}

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

	// C++98 防拷贝
	Singleton(Singleton const&);
	Singleton& operator=(Singleton const&);

	// or

	// C++11
	Singleton(Singleton const&) = delete;
	Singleton& operator=(Singleton const&) = delete;

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

int main()
{
	cout << Singleton::GetInstance() << endl;
	cout << Singleton::GetInstance() << endl;
	cout << Singleton::GetInstance() << endl;
	return 0;
}

        在自己类里不能定义自己的类型，但是自己类里定义自己类的指针是可以的，而且要定义成静态的，因为 GetInstance 也是静态的，因为静态的函数只能调用静态的成员函数。

        然后因为是定义的静态的成员函数，所以需要在类外去初始化。

        这个静态成员是在调用 main 函数之前就实例化了的。

        然后我们可以通过在 main 函数中调用 GetInstance ，而且可以看到地址是一样的，也就是说这个进程只为这个类实例化了一个对象。

        但是饿汉模式的缺点也很严重，就是如果这个项目的初始化很多，比如说加载数据库之类的配置初始化工作，那么这个配置初始化工作就要有很长时间，那么饿汉就很不合适了，因为启动进程非常慢。

• 懒汉模式

// 懒汉
// 优点：第一次使用实例对象时，创建对象。进程启动无负载。多个单例实例启动顺序自由控制。
// 缺点：复杂
#include <iostream>
#include <mutex>
#include <thread>
using namespace std;
class Singleton
{
public:
	static Singleton* GetInstance() {
		// 注意这里一定要使用Double-Check的方式加锁，才能保证效率和线程安全
		if (nullptr == m_pInstance) {
			m_mtx.lock();
			if (nullptr == m_pInstance) {
				m_pInstance = new Singleton();
			}
			m_mtx.unlock();
		}
		return m_pInstance;
	}
	// 实现一个内嵌垃圾回收类
	class CGarbo {
	public:
		~CGarbo() {
			if (Singleton::m_pInstance)
				delete Singleton::m_pInstance;
		}
	};
	// 定义一个静态成员变量，程序结束时，系统会自动调用它的析构函数从而释放单例对象
	static CGarbo Garbo;
private:
	// 构造函数私有
	Singleton() {};
	// 防拷贝
	Singleton(Singleton const&);
	Singleton& operator=(Singleton const&);
	static Singleton* m_pInstance; // 单例对象指针
	static mutex m_mtx; //互斥锁
};
Singleton* Singleton::m_pInstance = nullptr;
Singleton::CGarbo Garbo;
mutex Singleton::m_mtx;
void func(int n)
{
	cout << Singleton::GetInstance() << endl;
}

// 多线程环境下演示上面GetInstance()加锁和不加锁的区别。
int main()
{
	thread t1(func, 10);
	thread t2(func, 10);
	t1.join();
	t2.join();
	cout << Singleton::GetInstance() << endl;
	cout << Singleton::GetInstance() << endl;
}

         我们可以看到，我们将静态成员初始化为空，当我们调用 GetInstance 的时候再进行初始化。

        但是这里有一个问题，就是有线程安全的问题。

        就是当多线程的时候，刚进行判断了为 nullptr ，然后进去，还没有调用 new ，然后当前线程就被切走了，然后下一个线程来了还是 nullptr 就又进去 new 了一个对象，然后恢复第一个线程的上下文后又 new 了一个对象，第二个 new 的就将第一个的给覆盖了，所以这样就有错误了！

        所以这里我们就可以使用互斥锁~

        因为加锁要加在一个锁上才有用，所以我们也要将锁设为静态的，然后在类外进行初始化，我们这样就保证了只实例化出一个对象来，但是这样实际上还是有些问题的。

        问题就是当我们 new 出一个对象之后，我们在进行调用 GetInstance 的时候，还会不停的加锁解锁，我们知道，在我之前写的多线程的时候说过，加锁解锁是有性能消耗的，所以不断的加锁解锁是很不好的。

        所以这里我们就要使用双检测加锁：

         这样就减少加锁，获取了效率了。

        那么这里有的小伙伴还是会有一点问题，那么就单例对象什么时候释放。

        其实单例对象是不需要释放的，因为一般情况下单例在进程启动之后随时会被用，而且这个对象也不大，那么就可以不去释放。

        那么会有内存泄漏？其实如果进程是正常结束的，因为 new 出来得到的进程地址空间是虚拟内存，当结束之后就会将地址通过页表取消映射，那么 new 出来的资源就会还给 OS 。

        当然如果想要释放也是没有问题的：

        我们就实现一个 DelInstance 去手动调用的去释放。

        当然有大佬考虑到程序结束时，需要处理一下持久化保存一些数据，比方说要将数据写到硬盘上。那么就可以写一个析构函数，在析构函数中去处理。

        然后如果担心自己会忘记手动调用 DelInstance ，那么就可以通过设计一个类，类中实现一个析构函数。

        这个就是创建的时候创建一个 _gc，当 main 结束的时候 _gc 生命周期结束，然后调用它的析构函数，然后直接将单例对象进行析构。

        下面是我写的整体的代码：

class Singleton
{
public:
	static Singleton* GetInstance()
	{
		if (m_instance == nullptr)
		{
			_mtx.lock();
			if (m_instance == nullptr)
			{
				m_instance = new Singleton;
			}
			_mtx.unlock();
		}

		return m_instance;
	}

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

private:
	Singleton()
	{};
	~Singleton()
	{
		// 程序结束时，需要处理一下持久化保存一些数据
	}
	Singleton(Singleton const&) = delete;
	Singleton& operator=(Singleton const&) = delete;

	// 实现一个内嵌垃圾回收类
	class CGarbo {
	public:
		~CGarbo()
		{
			if (m_instance)
			{
				delete m_instance;
				m_instance = nullptr;
			}
		}
	};
	static Singleton* m_instance;
	static std::mutex _mtx;
	static CGarbo _gc;
};
Singleton* Singleton::m_instance = nullptr;
std::mutex Singleton::_mtx;
Singleton::CGarbo Singleton::_gc;

int main()
{
	cout << Singleton::GetInstance() << endl;
	cout << Singleton::GetInstance() << endl;
	cout << Singleton::GetInstance() << endl;
	return 0;
}

---

          上面的懒汉是标准的懒汉模式，当然还有大佬更绝，写了一个极致的懒汉：

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

private:
	Singleton()
	{};

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

	static Singleton* m_instance;
};

int main()
{
	cout << Singleton::GetInstance() << endl;
	cout << Singleton::GetInstance() << endl;
	cout << Singleton::GetInstance() << endl;
	return 0;
}

         因为局部的静态成员函数初始化是在调用 GetInstance 的时候才会初始化，而且就算是多线程来了也不会有问题，可以认为 static Singleton m_instance; 是原子的。

        如果说缺点，它也是有的，因为这个变量是在静态区的，如果单例对象太大，就不合适了，因为静态区的空间不适合太大的，而在堆上就没事，因为堆上的空间是很大的。

        再有缺点就是想主动释放单例对象是无法控制的。

懒汉模式和饿汉模式的对比

饿汉

优点：简单

缺点：

1. 如果单例对象构造函数工作比较多，会导致程序启动慢,迟迟进不了入口main函数
2. 如果有多个单例对象，他们之间有初始化依赖关系，饿汉模式也会有问题。
       比如有A和B两个单例类，要求A单例先初始化，B必须在A之后初始化。那么饿汉无法保证这种场景下面用懒汉就可以，懒汉可以先调用 A::GetInstance() ，再调用 B::GetInstance() 。

懒汉

优点：解决上面饿汉的缺点。因为他是第一次调用 GetInstance 时创建初始化单例对象

缺点：相对饿汉，复杂一点点。

         如上就是 特殊类的设计 的所有知识，如果大家喜欢看此文章并且有收获，可以支持下 兔7 ，给 兔7 三连加关注，你的关注是对我最大的鼓励，也是我的创作动力~！

        再次感谢大家观看，感谢大家支持！