【C++】特殊类设计 | 单例设计模式

- 前言
- 一、设计一个类，不能被拷贝
- 二、设计一个只能在堆上创建对象的类
- 三、设计一个只能在栈上创建对象的类
- 四、设计一个类，不能被继承
- 五、设计一个类，只能创建一个对象(单例模式)
- - 5.1 饿汉模式
  - 5.2 懒汉模式
  - 5.3 饿汉模式VS懒汉模式

前言

本篇文章我们重点要讲解的内容为单例模式，单例模式有什么特点？有什么好处？下面就让我们一起进入学习吧！！

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

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

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;//...
};

二、设计一个只能在堆上创建对象的类

实现方式：

思路一：将类的构造函数私有和拷贝构造声明成私有，防止别人调用拷贝在栈上生成对象。提供一个静态的成员函数，在该静态成员函数中完成堆对象的创建。
思路二：将类的析构函数私有，提供一个释放资源的接口即可。因为对象出了作用域，会调用对象的析构函数来完成资源的释放，而在栈区或者静态区上创建的对象无法调用析构函数，但是在堆上创建的对象提供了释放资源的接口来完成资源的释放。

思路一代码：

class HeapOnly
{
public:static HeapOnly* CreateObject(){return new HeapOnly;   }HeapOnly(const HeapOnly& hp) = delete;HeapOnly operator=(const HeapOnly& hp) = delete;private:HeapOnly(){}int _x = 0;
};int main()
{HeapOnly* hp = HeapOnly::CreateObject();delete hp;/*HeapOnly a1;static HeapOnly a2;HeapOnly copy(*hp);*/return 0;
}

思路二代码：

class HeapOnly
{
public:HeapOnly(){}static void Delete1(HeapOnly* p){delete p;}void Delete2(){delete this;}HeapOnly(const HeapOnly& hp) = delete;HeapOnly operator=(const HeapOnly& hp) = delete;private:~HeapOnly(){}int _x = 0;
};int main()
{HeapOnly* p = new HeapOnly;HeapOnly::Delete1(p);  // 静态成员函数HeapOnly* s = new HeapOnly;s->Delete2();   // 普通成员函数//HeapOnly copy(*s);  // //HeapOnly s;return 0;
}

三、设计一个只能在栈上创建对象的类

思路：与上述方法相同，我们将构造函数私有化，提供一个静态成员函数来返回匿名对象，但其实我们返回的不是匿名对象而是匿名对象的临时拷贝变量，因此我们需要提供拷贝构造，提供了拷贝构造那么就不能限制对象在栈区/静态区上进行拷贝构造了，不能在堆上创建对象我们可以通过删除operator new 函数来实现。

class StackOnly
{
public:static StackOnly CreateObject(){return StackOnly();}//	// 不能防拷贝//	StackOnly(const StackOnly& hp) = delete;//	StackOnly& operator=(const StackOnly& hp) = delete;// 限制在堆上创建对象void* operator new(size_t n) = delete;private:StackOnly(){}int _x = 0;
};int main()
{StackOnly s = StackOnly::CreateObject();static StackOnly copy(s);// StackOnly ps* = new StackOnly;   //static StackOnly ps = new StackOnly;return 0;
}

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

C++98 的做法是将构造函数私有化，派生类中调不到基类的构造函数，则无法继承。

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

而 C++ 11 的做法是 final 关键字修饰类，表示该类不能被继承。

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

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

设计模式：设计模式（Design Pattern）是一套被反复使用、多数人知晓的、经过分类的、代码设计经验的总结。为什么会产生设计模式这样的东西呢？就像人类历史发展会产生兵法。最开始部落之间打仗时都是人拼人的对砍。后来春秋战国时期，七国之间经常打仗，就发现打仗也是有套路的，后来孙子就总结出了《孙子兵法》。孙子兵法也是类似。
使用设计模式的目的：为了代码可重用性、让代码更容易被他人理解、保证代码可靠性。设计模式使代码编写真正工程化；设计模式是软件工程的基石脉络，如同大厦的结构一样。

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

单例模式有两种实现模式，饿汉模式和懒汉模式。

5.1 饿汉模式

不管你将来用不用，程序启动时就创建一个唯一的实例对象，在进入main函数之前就已经实例化出一个对象。

整体思路：

把数据放进一个类里面，将这个类设计成单例类
把构造函数私有化，防止其随意创建对象，提供一个静态成员函数来返回单例对象
根据性质设计为饿汉或懒汉模式

饿汉模式的简化代码如下：

class Singleton 
{
public:static Singleton* GetInstance(){return _ins;   // 每次返回的对象都是指向同一块空间的}// 插入数据需要保证线程安全问题void Add(const string& str){_mtx.lock();_v.emplace_back(str);_mtx.unlock();}void Print(){_mtx.lock();for (auto& e : _v){cout << e << endl;}cout << endl;_mtx.unlock();}private:Singleton()  // 构造函数私有化，不能随意创建对象{}mutex _mtx;vector<string> _v;static Singleton* _ins;
};Singleton* Singleton::_ins = new Singleton;    // 在未进入main函数之前就已经实例化出来了int main()
{srand(time(0));int n = 100;thread t1([n]() {for (size_t i = 0; i < n; i++){Singleton::GetInstance()->Add("t1线程，第" + to_string(i) + "个" + to_string(rand()));}});thread t2([n]() {for (size_t i = 0; i < n; i++){Singleton::GetInstance()->Add("t2线程，第" + to_string(i) + "个" + to_string(rand()));}});t1.join();t2.join();Singleton::GetInstance()->Print();return 0;
}

如果这个单例对象在多线程高并发环境下频繁使用，性能要求较高，那么显然使用饿汉模式来避免资源竞争，提高响应速度更好。

5.2 懒汉模式

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

懒汉模式的简化代码：

class Singleton
{
public:static Singleton* GetInstance(){// 这里的判断是为了提高效率，假设对象已经创建出来了，那么我们就直接返回原来的对象即可if (_ins == nullptr)  {_imtx.lock();// 这里的判断是为了保证线程安全，假设没有这个条件判断，当t1获得锁然后new一个对象后解锁，此时t1时间片到了，t2获得了锁，如果此时不加判断的话那么就会覆盖掉t1 new的对象if (_ins == nullptr) {_ins = new Singleton;}_imtx.unlock();}return _ins;}void Add(const string& str){_mtx.lock();_v.emplace_back(str);_mtx.unlock();}void Print(){_mtx.lock();for (auto& e : _v){cout << e << endl;}cout << endl;_mtx.unlock();}static void DelInstance(){_imtx.lock();if (_ins){delete _ins;_ins = nullptr;}_imtx.unlock();}// 单例对象回收 —— Singleton析构之前先析构成员变量GC的资源，GC析构又会调用DelInstance隐式回收单例对象class GC{public:~GC(){DelInstance();}};private:Singleton(){}mutex _mtx;vector<string> _v;static Singleton* _ins;static mutex _imtx;static GC _gc;
};mutex Singleton::_imtx;    // 非对象成员函数中需要添加同一把锁来保证线程安全
Singleton* Singleton::_ins = nullptr;
Singleton::GC Singleton::_gc;int main()
{srand(time(0));int n = 100;thread t1([n]() {for (size_t i = 0; i < n; i++){Singleton::GetInstance()->Add("t1线程，第" + to_string(i) + "个" + to_string(rand()));}});thread t2([n]() {for (size_t i = 0; i < n; i++){Singleton::GetInstance()->Add("t2线程，第" + to_string(i) + "个" + to_string(rand()));}});t1.join();t2.join();Singleton::GetInstance()->Print();return 0;
}