【C++】特殊类的设计（只在堆、栈创建对象，单例对象）

🌏博客主页： 主页
🔖系列专栏： C++
❤️感谢大家点赞👍收藏⭐评论✍️
😍期待与大家一起进步！

---

---

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

实现方式：

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

class HeapOnly
{
public:static HeapOnly* CreateObj(){return new HeapOnly;}
private:HeapOnly(){//...}HeapOnly(const HeapOnly& hp) = delete;HeapOnly& operator=(const HeapOnly& hp) = delete;
};

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

实现方法：
1.同上将构造函数私有化，然后设计静态方法创建对象返回即可
2.禁用堆上的创建方式，new=operator new+构造函数
3.operator new 是系统提供的全局函数，new在底层调用operator new全局函数来申请空间

class StackOnly
{
public:static StackOnly CreateObj(){return StackOnly();}// 禁掉operator new可以把下面用new 调用拷贝构造申请对象给禁掉// StackOnly obj = StackOnly::CreateObj();// StackOnly* ptr3 = new StackOnly(obj);//  new==operator new + 构造//delete==析构+operator deletevoid* operator new(size_t size) = delete;void operator delete(void* p) = delete;
private://构造函数私有化//拷贝构造函数不能私有化，因为我们上面CreateObj()返回，需要//用到拷贝构造函数StackOnly():_a(0){}
private:int _a;
};

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

1.方法一：

//  构造函数私有化，派生类中调不到基类的构造函数。则无法继承
class NonInherit
{
public:static NonInherit GetInstance(){return NonInherit();}
private:NonInherit(){}
};

2.方法二：

//final关键字，final修饰类，表示该类不能被继承。
class A  final
{// ....
};

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

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

1.饿汉模式

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

class Singleton
{
public:// 2、提供获取单例对象的接口函数static Singleton& GetInstance(){return _sinst;}private:// 1、构造函数私有//构造函数私有也不能调用new了Singleton(){// ...}// 3、防拷贝Singleton(const Singleton& s) = delete;Singleton& operator=(const Singleton& s) = delete;static Singleton _sinst;//虽然为静态类型，但依然可以使用对应类里面的构造函数
};
Singleton Singleton::_sinst;// 在程序入口之前就完成单例对象的初始化

饿汉模式:一开始(main函数之前)就创建单例对象
1、如果单例对象初始化内容很多，影响启动速度
2、如果两个单例类，互相有依赖关系。
假设有A B两个单例类，要求A先创建，B再创建，B的初始化创建依赖A，但在main的外面没办法确定哪个类先被创建，可能会出现问题

2.懒汉模式

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

1.普通场景

class Singleton{public:// 2、提供获取单例对象的接口函数static Singleton& GetInstance(){if (_psinst == nullptr){// 第一次调用GetInstance的时候创建单例对象_psinst = new Singleton;}return *_psinst;}private:// 1、构造函数私有Singleton(){// ...}~Singleton(){}// 3、防拷贝Singleton(const Singleton& s) = delete;Singleton& operator=(const Singleton& s) = delete;static Singleton* _psinst;};Singleton* Singleton::_psinst = nullptr;

2.特殊场景

1、中途需要显示释放

static void DelInstance(){if (_psinst){delete _psinst;_psinst = nullptr;}//自己写一个静态的函数，进行释放操作}

2.程序结束时，需要做一些特殊动作（如持久化）

方法：
1.我们把要写入的数据过程放到析构函数中
2.我们可以像智能指针那样使用，在类里面再定义一个类GC，让GC的析构函数专门用来管理Singleton的析构函数，然后创建GC的对象，因为GC不是指针类型为普通类型，程序结束的时候会自动调用其析构函数，这样也就完成了Singleton的析构函数

class GC{public:~GC(){Singleton::DelInstance();}};~Singleton(){cout << "~Singleton()" << endl;// map数据写到文件中FILE* fin = fopen("map.txt", "w");for (auto& e : _dict){fputs(e.first.c_str(), fin);fputs(":", fin);fputs(e.second.c_str(), fin);fputs("\n", fin);}}

3.源码

class Singleton{public:// 2、提供获取单例对象的接口函数static Singleton& GetInstance(){if (_psinst == nullptr){// 第一次调用GetInstance的时候创建单例对象_psinst = new Singleton;}return *_psinst;}// 一般单例不用释放。// 特殊场景：1、中途需要显示释放  2、程序结束时，需要做一些特殊动作（如持久化）static void DelInstance(){if (_psinst){delete _psinst;_psinst = nullptr;}}class GC{public:~GC(){Singleton::DelInstance();}};private:// 1、构造函数私有Singleton(){// ...}~Singleton(){cout << "~Singleton()" << endl;// map数据写到文件中FILE* fin = fopen("map.txt", "w");for (auto& e : _dict){fputs(e.first.c_str(), fin);fputs(":", fin);fputs(e.second.c_str(), fin);fputs("\n", fin);}}// 3、防拷贝Singleton(const Singleton& s) = delete;Singleton& operator=(const Singleton& s) = delete;map<string, string> _dict;// ...static Singleton* _psinst;static GC _gc;};Singleton* Singleton::_psinst = nullptr;Singleton::GC Singleton::_gc;class A {public:A() {cout << "gouzao" << endl;}~A() {cout << "析构函数" << endl;}};