一、单例模式的设计套路:
思考:如何绕过常规的构造函数,提供一种机制来保证一个类只有一个实例。
1. 铺垫:静态成员函数特性的总结
使用static关键字修饰类成员函数时,就是把这个成员函数升级成了全局函数。只不过这个全局函数隐藏在这个类之中。
(1) 静态成员函数是没有this指针的。
(2) 静态成员函数是不可以调用类中的非静态成员,只能调用或访问类中的静态成员。
(3) 静态成员函数不依赖于成员对象,可以使用 类名+类域访问符的形式直接调用。
总结:静态成员函数与静态成员对象一样,是服务于整个类的,而不依赖于某个对象。
2. 思考题的解决过程:
(1) 要实现单例模式,先把构造函数私有化。
私有化带来的问题是:外部不可以定义对象,即不可以从外部调到类的构造函数。
解决:在类内定义一个公开的接口,返回本类对象的指针。
(2) 在public 权限下定义一个函数,返回出本类对象的指针。
问题:若函数是一个普通函数,需要依赖于类对象的调用才可以,这与只产生一个单例相矛盾。
解决:把这个函数升级为静态函数,无需依赖于对象的调用,可以直接调用。
(3) 把这个函数升为静态函数。
问题:静态函数是没有this指针,无法调用类中属性(无法访问普通属性)。
解决:把类中的属性升级为静态属性。静态成员函数只能调用静态成员属性。
(4) 把类中的本类的指针,升级为静态属性
至此,一个单例模式的程序完成。
二、单例设计模式:
单例模式分为:饿汉式与懒汉式
三、饿汉式单例设计模式
1. 饿汉式:
(1) 构造函数私有化
(2) 在public权限下定义一个公有接口,返回本类对象的指针
(3) 公有接口提升为静态函数。
(4) 将类中属性定义为静态属性
(5) 因为是静态成员函数,所以不能在静态成员函数中书写开辟空间的逻辑,应该把开辟空间的逻辑写在全局作用域中。
2. 代码实现:
#include <iostream>
using namespace std;
class Singleton
{
private: //对类内开放,对类外不开放
static Singleton* singleton; //定义指针
Singleton()
{
cout << "Singleton的构造"<< endl;
}
public:
//定义一个公有接口,返回本类对象的指针
static Singleton* getInstance()
{
return singleton;
}
void showInfo()
{
cout << this << endl;
}
//把编译器自动提供的拷贝构造与 = 号运算符重载移除
Singleton(const Singleton& other) = delete;
void operator = (const Singleton& other) = delete;
};
Singleton* Singleton::singleton = new Singleton;
int main()
{
Singleton* s1 = Singleton::getInstance();
Singleton* s2 = Singleton::getInstance();
Singleton* s3 = Singleton::getInstance();
cout << s1 << ","<< s2 <<"," << s3 <<endl; //s1、s2和s3 地址一样
return 0;
}
3. 代码结果:
4. 饿汉式缺点:
静态成员空间只能初始化一次,这块空间是不能释放的,这就占用了空间资源。每使用一次饿汉式单例,程序一加载singleton这个指针就开辟空间,造成内存浪费。
四、懒汉式单例设计模式
1. 模式出现的问题与解决方式
》问题:当多进程存在的环境下,构造函数是需要耗费时间的,当一个进程开辟空间构造一个实例时,可能有另一个进程进来,也构造了一个实例,这样就不够安全。
》解决1:加智能锁。不使用智能锁采用普通锁,lock()和unlock()这种加锁与解锁的方式,若空间没开辟成功直接返回,这时锁没解开就生成死锁。而智能锁不管有没有成功开辟空间,出了作用域的同时调用lock()的析构函数把这个锁释放了,不会造成死锁。
》解决2:使用原子锁。
2. 代码实现:
#include <iostream>
#include <mutex>
using namespace std;
//定义全局锁
mutex mtx;
class Singleton
{
private:
static Singleton* singleton;
Singleton()
{
cout << "Singleton的构造" << endl;
}
~Singleton()
{
cout <<"Singleton的析构" << endl;
}
public:
static Singleton* getInstance()
{
lock_guard<mutex> lock(mtx);
//mtx.lock(); 普通锁
if(singleton == nullptr)
{
singleton = new Singleton;
}
//mtx.unlock();
return singleton;
}
void showInfo()
{
cout << this << endl;
}
//专门设计一个释放堆区空间的逻辑
static void destroy()
{
//不要把这个逻辑放在析构函数中,将会出现无限递归
if(singleton != nullptr)
{
delete singleton;
}
}
};
Singleton* Singleton::singleton = nullptr;
int main()
{
Singleton* s1 = Singleton::getInstance();
Singleton* s2 = Singleton::getInstance();
Singleton* s3 = Singleton::getInstance();
s1->showInfo();
s2->showInfo();
s3->showInfo();
Singleton::destroy();
return 0;
}
3. 代码结果:
4. 注意:
销毁不能在析构函数中写,本身是单例销毁会陷入无限的递归、无限的死循环,所以要专门定义一个静态函数来销毁这个堆的空间。