【施磊C++】设计模式

---

前言

本文介绍了常见的设计模式，基于施磊老师的C++课程。

---

一、单例模式

单例模式：一个类不管创建多少次对象，永远只能得到该类型的一个对象的实例，单例模式分为饿汉单例模式和懒汉单例模式。实现单例模式需要注意的五个点：
1、需要将构造函数私有化，这样保证使用者无法通过构造函数创建新的单例对象
2、需要定义一个唯一的static实例对象
3、需要提供对外的接口返回这个唯一的实例对象
4、需要删除拷贝构造函数和赋值运算符重载函数，保证使用者不能通过者二者构造新的对象
5、在类内声明了static对象，还需要在类外进行定义

1、饿汉单例模式

饿汉单例模式：还没有获取实例对象，对象就已经生成了，饿汉单例模式一定是线程安全的。

#include <iostream>

using namespace std;

/*
饿汉单例模式：
    还没有获取实例对象，对象就已经生成了，饿汉单例模式一定是线程安全的
懒汉单例模式：
    唯一的实例对象，只有在第一次获取他时，才产生
*/
class Singleton {
   
   
public:
    static Singleton* getInstance() {
   
      // 3、提供对外的接口
        return &instance;
    }
private:
    static Singleton instance;  // 2、定义一个唯一的实例对象
    Singleton() {
   
                  // 1、构造函数私有化

    }
    Singleton(const Singleton&) = delete;       // 4、删除拷贝构造函数和赋值重载函数
    Singleton& operator=(const Singleton&) = delete;
};

Singleton Singleton::instance;

int main()
{
   
   
    Singleton *p1 = Singleton::getInstance();
    Singleton *p2 = Singleton::getInstance();
    Singleton *p3 = Singleton::getInstance();

    // Singleton t = *p1;

    return 0;
}

2、懒汉单例模式

懒汉单例模式：唯一的实例对象，只有在第一次获取他时，才产生。
在实际的单例模式对象中，初始化一个单例对象可能需要耗费大量的资源，在还未使用就对单例对象进行生成会导致大量的性能损耗，因此懒汉单例模式的使用更加广泛。
懒汉单例模式的实现与饿汉类似，不过将成员变量instance变为了指针：

#include <iostream>

using namespace std;

/*
饿汉单例模式：
    还没有获取实例对象，对象就已经生成了，饿汉单例模式一定是线程安全的
懒汉单例模式：
    唯一的实例对象，只有在第一次获取他时，才产生
*/
class Singleton {
   
   
public:
    static Singleton* getInstance() {
   
      // 3、提供对外的接口
        if (instance == nullptr) {
   
   
            instance = new Singleton();
        }
        return instance;
    }
private:
    static Singleton *instance;  // 2、定义一个唯一的实例对象
    Singleton() {
   
                   // 1、构造函数私有化

    }
    Singleton(const Singleton&) = delete;       // 4、删除拷贝构造函数和赋值重载函数
    Singleton& operator=(const Singleton&) = delete;
};

Singleton *Singleton::instance = nullptr;

int main()
{
   
   
    Singleton *p1 = Singleton::getInstance();
    Singleton *p2 = Singleton::getInstance();
    Singleton *p3 = Singleton::getInstance();

    // Singleton t = *p1;

    return 0;
}

二、线程安全的懒汉单例模式

显然，上节中实现的懒汉单例模式并不是线程安全的，getInstance函数并不是可重入函数。为了保证线程安全性，有两种实现方式：

1、锁+双重判断

注意volatile关键字的使用：

#include <iostream>
#include <mutex>
using namespace std;

std::mutex mtx;

class Singleton {
   
   
public:
    static Singleton* getInstance() {
   
      // 3、提供对外的接口
        if (instance == nullptr) {
   
   
            lock_guard<std::mutex> guard(mtx);
            if (instance == nullptr) {
   
   
                instance = new Singleton();
            }
        }
        return instance;
    }
private:
    static Singleton *volatile instance;  // 2、定义一个唯一的实例对象
    Singleton() {
   
                   // 1、构造函数私有化

    }
    Singleton(const Singleton&) = delete;       // 4、删除拷贝构造函数和赋值重载函数
    Singleton& operator=(const Singleton&) = delete;
};

Singleton *volatile Singleton::instance = nullptr;

int main()
{
   
   
    Singleton *p1 = Singleton::getInstance();
    Singleton *p2 = Singleton::getInstance();
    Singleton *p3 = Singleton::getInstance();

    // Singleton t = *p1;

    return 0;
}

2、静态局部变量

由于静态局部变量在第一次运行时才进行初始化，那么其就只有在第一次调用getInstance时才会初始化，并且对于函数静态局部变量的初始化，在汇编指令层面会自动添加线程互斥指令，因此不必担心线程安全。

#include <iostream>
using namespace std;

class Singleton {
   
   
public:
    static Singleton* getInstance() {
   
      
        static Singleton instance;
        return &instance;
    }
private:
    Singleton() {
   
                  

    }
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;
};

int main()
{
   
   
    Singleton *p1 = Singleton::