单例模式

认识单例模式之前先认识一下几种常见的特殊类的设计。

特殊类的设计

• 设计一个类 只能再堆上创建对象

  • 只能再堆上创建，则通过new来创建对象。

    1. 将类的构造函数设为私有，以防止外部直接创建对象。
    2. 提供一个静态成员函数，用于在堆上创建对象，并返回指向该对象的指针
    3. 在类的析构函数中释放对象的内存，以确保对象在不再需要时被正确销毁。

    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对象。创建方式如下：

    1. 将类的构造函数设为私有，防止外部直接调用构造函数在堆上创建对象。
    2. 在类中定义一个静态成员函数，用于创建对象，并返回该对象的引用或指针。

    ```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），设计模式就是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式的目的就是为了可重用代码、让代码更容易被他人理解、保证代码可靠性程序的重用性。

单例模式指的就是一个类只能创建一个对象，该模式可以保证系统中该类只有一个实例，并提供一个访问它的全局访问点，该实例被所有程序模块共享。

单例模式有两种实现方式，分别是饿汉模式和懒汉模式

饿汉模式

单例模式的实现方式：

1. 私有化构造函数：确保其他类无法直接实例化该类，只能通过指定的方法获取类的实例。
2. 私有静态成员变量：保存类的唯一对象。并在程序入口之前完成单例对象的初始化。
3. 公有静态方法：提供对唯一实例的访问。

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();
}

懒汉模式

懒汉模式的实现方式：

1. 私有化构造函数：确保其他类无法直接实例化该类，只能通过指定的方法获取类的实例。
2. 私有静态成员变量：保存类的唯一对象，将其初始化为空。
3. 公有静态方法：提供对唯一实例的访问。如果实例不存在，则创建一个新实例并返回；如果实例已存在，则返回现有实例

// 懒汉模式
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饿汉

• 饿汉
  1. 在类加载时就创建实例。无论是否使用该实例，都会在类加载时被创建。如果这个类很大，会影响程序的启动速度。
  2. 在mian程序加载之前就会被实例化，不存在线程安全问题
  3. 使用简单
• 懒汉
  1. 在需要时才创建实例。也就是说，实例的创建延迟到第一次使用时才发生。
  2. 在多线程环境下需要考虑线程安全性，特别是在第一次获取实例时，可能会存在多个线程同时创建实例的问题。需要通过加锁或者双重检查锁定等技术来确保线程安全性。
  3. 使用复杂

懒汉的线程安全

上面写的懒汉单例并不是线程安全的，在多线程场景下，存在线程安全的问题。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修饰成员变量和成员函数的特征：

1. 静态成员变量：

   • 所有类的对象共享静态成员变量的值。
   • 在类声明中声明为静态成员变量，但在类外部必须在类外进行定义和初始化。
   • 静态成员变量的内存只分配一次，直到程序结束才会被释放。
   • 可以在类外部通过类名和作用域解析运算符（::）来访问静态成员变量。

2. 静态成员函数：

   • 不与任何特定的对象相关联，可以直接通过类名调用。
   • 静态成员函数没有隐含的this指针。
   • 静态成员函数不能访问非静态成员变量和非静态成员函数（除非它们是同一个类中的静态成员）。
   • 由于它们不与特定对象相关联，因此无法在静态成员函数中使用this指针。

在单例模式中，需要将实例保存在静态成员变量中，是因为：

1. 全局可访问性：静态成员变量属于类而不是对象，因此可以被该类的所有对象访问。这符合单例模式的要求，即只有一个实例，并且可以在任何地方访问到该实例。
2. 生命周期与类相同：静态成员变量随着类的加载而初始化，而不是随着对象的创建而初始化。这意味着无论是否存在对象，静态成员变量都会在类加载时创建，从而保证了在整个应用程序生命周期内只有一个实例存在。

因此，将单例实例保存在静态成员变量中能够满足单例模式的要求，确保了实例的全局可访问性和唯一性。