单例模式
认识单例模式之前先认识一下几种常见的特殊类的设计。
特殊类的设计
设计一个类 只能再堆上创建对象
只能再堆上创建，则通过new来创建对象。
- 将类的构造函数设为私有，以防止外部直接创建对象。
- 提供一个静态成员函数，用于在堆上创建对象，并返回指向该对象的指针
- 在类的析构函数中释放对象的内存，以确保对象在不再需要时被正确销毁。
class HeapOnly { public: // 获取堆上对象的静态成员函数 static HeapOnly* CreateObj() { return new HeapOnly(); } // 删除拷贝构造函数和赋值运算符，以确保只能通过 create() 创建对象 HeapOnly(const HeapOnly&) = delete; HeapOnly& operator=(const HeapOnly&) = delete; private: // 将构造函数设为私有，以防止外部直接创建对象 HeapOnly() { // 可以在这里进行初始化操作 } // 在析构函数中释放对象的内存 ~HeapOnly() { // 可以在这里进行资源释放操作 } };HeapOnly类的构造函数是私有的，外部无法直接调用。向外提供的
CreateObj方法必须定义为static成员函数。因为外部调用该接口就是为了获取对象的，而非静态成员函数必须通过对象才能调用，静态成员函数直接使用类名::函数名即可调用。将拷贝构造函数和赋值运算符重载函数之间禁用，也可以设置为私有属性，以防通过拷贝和赋值创建对象。
使用示例：
int main() { // 创建堆上的对象 HeapOnly* obj = HeapOnly::create(); // 使用对象... // 删除对象 delete obj; return 0; }
设计一个类 只能再栈上创建对象
只能再栈上创建对象，说明不能通过new创建对象，也不能定义为static对象。创建方式如下：
- 将类的构造函数设为私有，防止外部直接调用构造函数在堆上创建对象。
- 在类中定义一个静态成员函数，用于创建对象，并返回该对象的引用或指针。
```cpp
class StackOnly {
public:// 获取栈上对象的静态成员函数 static StackOnly& create() { // 在静态成员函数中创建对象，返回对象的引用 static StackOnly instance; return instance; } // 删除拷贝构造函数和赋值运算符，以防止通过拷贝或赋值创建对象 StackOnly(const StackOnly&) = delete; StackOnly& operator=(const StackOnly&) = delete;
private:
// 将构造函数设为私有，防止外部直接创建对象
StackOnly() {
// 可以在这里进行初始化操作
}
};
int main() {
// 创建栈上的对象
StackOnly& obj = StackOnly::create();
return 0;
}
```
将
StackOnly类的构造函数私有化，外部无法直接调用。限制了通过new创建对象和static对象。静态局部对象的引用是存储在栈上的。
将拷贝构造函数和赋值运算符重载函数之间禁用，也可以设置为私有属性，以防通过拷贝和赋值创建对象。
设计一个类 不能被拷贝
- 将拷贝构造函数和赋值运算符设置为私有，或者直接使用delete禁用即可。
class NonCopyable { public: NonCopyable() { } // 默认构造函数 // 禁用拷贝构造函数和拷贝赋值运算符 NonCopyable(const NonCopyable&) = delete; NonCopyable& operator=(const NonCopyable&) = delete; }; int main() { NonCopyable obj1; // NonCopyable obj2 = obj1; // 这行会导致编译错误，因为拷贝构造函数被删除了 // NonCopyable obj3; // obj3 = obj1; // 这行会导致编译错误，因为拷贝赋值运算符被删除了 return 0; }
设计一个类 不能被继承
将该类的构造函数设置为私有即可，因为子类对象构造时，必须先调用父类构造，构造父类那一部分成员。将其私有化后，子类对象创建对象时，无法调用父类构造函数进行初始化。
class NonInherit { public: static NonInherit CreateObj() { return NonInherit(); } private: //将构造函数设置为私有 NonInherit() { } };也可以使用C++11提供的关键字
final。别final修饰的类，无法被继承class NonInherit final { //... };
设计一个类 只能创建一个对象
- 一个类只能创建一个对象，将其称之为单例模式。
单例模式
单例模式是一种设计模式（Design Pattern），设计模式就是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式的目的就是为了可重用代码、让代码更容易被他人理解、保证代码可靠性程序的重用性。
单例模式指的就是一个类只能创建一个对象，该模式可以保证系统中该类只有一个实例，并提供一个访问它的全局访问点，该实例被所有程序模块共享。
单例模式有两种实现方式，分别是饿汉模式和懒汉模式
饿汉模式
单例模式的实现方式：
- 私有化构造函数：确保其他类无法直接实例化该类，只能通过指定的方法获取类的实例。
- 私有静态成员变量：保存类的唯一对象。并在程序入口之前完成单例对象的初始化。
- 公有静态方法：提供对唯一实例的访问。
class Singleton
{
public:
//公有静态方法
static Singleton* GetInstace()
{
return _inst;
}
//禁用拷贝构造和赋值运算符
Singleton(const Singleton& s) = delete;
Singleton& operator=(const Singleton) = delete;
private:
//私有化构造函数
Singleton()
{
}
//私有静态成员变量
static Singleton* _inst;
};
Singleton* Singleton::_inst = new Singleton;//静态成员变量的初始化
int main()
{
//获取单例对象
Singleton* ojb = Singleton::GetInstace();
}
懒汉模式
懒汉模式的实现方式：
- 私有化构造函数：确保其他类无法直接实例化该类，只能通过指定的方法获取类的实例。
- 私有静态成员变量：保存类的唯一对象，将其初始化为空。
- 公有静态方法：提供对唯一实例的访问。如果实例不存在，则创建一个新实例并返回；如果实例已存在，则返回现有实例
// 懒汉模式
class Singleton
{
public:
//公有静态方法
static Singleton* GetInstance()
{
if (_inst == nullptr)
{
_inst = new Singleton;
}
return _inst;
}
//禁用拷贝构造和赋值运算符
Singleton(const Singleton&) = delete;
Singleton& operator=(const Singleton&) = delete;
private:
//私有构造函数
Singleton()
{
}
//私有静态成员变量
static Singleton* _inst;
};
Singleton* Singleton::_inst = nullptr;
int main()
{
//获取单例对象
Singleton* obj = Singleton::GetInstance();
return 0;
}
懒汉VS饿汉
- 饿汉
- 在类加载时就创建实例。无论是否使用该实例，都会在类加载时被创建。如果这个类很大，会影响程序的启动速度。
- 在mian程序加载之前就会被实例化，不存在线程安全问题
- 使用简单
- 懒汉
- 在需要时才创建实例。也就是说，实例的创建延迟到第一次使用时才发生。
- 在多线程环境下需要考虑线程安全性，特别是在第一次获取实例时，可能会存在多个线程同时创建实例的问题。需要通过加锁或者双重检查锁定等技术来确保线程安全性。
- 使用复杂
懒汉的线程安全
上面写的懒汉单例并不是线程安全的，在多线程场景下，存在线程安全的问题。GetInstance函数第一次调用时，需要对_inst进行写入操作，这个操作不是线程安全的，多个线程可能同时调用GetInstance进行写入，如果不对此过程进行加锁保护，多线程下就会各自创建出一个对象。
对于饿汉模式来讲，不存在线程安全的问题，因为在main函数之前就已经创建好对象了。
在GetInstance中创建单例对象进行加锁保护。
static Singleton* GetInstance()
{
if (_inst == nullptr)
{
_mtx.lock();
if (_inst == nullptr)
{
_inst = new Singleton;
}
_mtx.unlock();
}
return _inst;
}
进行双重检查加锁来保证线程安全。双重检查会提高效率，如果是单检查，如下：
static Singleton* GetInstance()
{
_mtx.lock();
if (_inst == nullptr)
{
_inst = new Singleton;
}
_mtx.unlock();
return _inst;
}
这样每次访问单例对象时都要进行加锁，加锁之后才能进行判断。双检查之后，只有第一次访问单例对象时才需要加锁。后续访问时无需加锁了。提高了效率。
单例对象的释放
单例对象创建后一般在整个程序运行期间都可能会使用，所以我们可以不考虑单例对象的释放，程序正常结束时会自动将资源归还给操作系统。
有些场景下可能需要提前释放单例对象，可以参考一下方式：
- 提供一个公有的
DelInstance函数，在该函数中进行单例对象释放的操作，当不需要单例对象时，调用此函数进行单例对象的释放。函数如下：
static void DelInstance()
{
_mtx.lock();
if (_inst != nullptr)
{
delete _inst;
_inst = nullptr;
}
_mtx.unlock();
}
释放操作只能调用一次，单检查加锁足够了，无需双检查加锁。
注意：单例模式中的单例对象和互斥锁，和提供的公有方法都是static的。
首先要明确static修饰成员变量和成员函数的特征：
静态成员变量：
- 所有类的对象共享静态成员变量的值。
- 在类声明中声明为静态成员变量，但在类外部必须在类外进行定义和初始化。
- 静态成员变量的内存只分配一次，直到程序结束才会被释放。
- 可以在类外部通过类名和作用域解析运算符（::）来访问静态成员变量。
静态成员函数：
- 不与任何特定的对象相关联，可以直接通过类名调用。
- 静态成员函数没有隐含的this指针。
- 静态成员函数不能访问非静态成员变量和非静态成员函数（除非它们是同一个类中的静态成员）。
- 由于它们不与特定对象相关联，因此无法在静态成员函数中使用this指针。
在单例模式中，需要将实例保存在静态成员变量中，是因为：
- 全局可访问性：静态成员变量属于类而不是对象，因此可以被该类的所有对象访问。这符合单例模式的要求，即只有一个实例，并且可以在任何地方访问到该实例。
- 生命周期与类相同：静态成员变量随着类的加载而初始化，而不是随着对象的创建而初始化。这意味着无论是否存在对象，静态成员变量都会在类加载时创建，从而保证了在整个应用程序生命周期内只有一个实例存在。
因此，将单例实例保存在静态成员变量中能够满足单例模式的要求，确保了实例的全局可访问性和唯一性。
