【C++ | 设计模式】单例模式的详解与实现

于 2024-08-28 21:59:10 发布
阅读量442 收藏 3
点赞数 12
分类专栏： 设计模式 文章标签： c++ 设计模式 单例模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42037383/article/details/141399382
版权

1.简述

单例模式（Singleton Pattern）是设计模式中最简单的形式之一，其目的是使得类的一个对象成为系统中的唯一实例。

这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一对象的方式，可以直接访问，不需要实例化该类的对象。

2.UML 结构图

3.要点

单例模式的要点有三个：

  • 单例类有且仅有一个实例

  • 单例类必须自行创建自己的唯一实例

  • 单例类必须给所有其他对象提供这一实例

从具体实现角度来说，可分为以下三点：

  • 提供一个 private 构造函数（防止外部调用而构造类的实例）

  • 提供一个该类的 static private 对象

  • 提供一个 static public 函数，用于创建或获取其本身的静态私有对象（例如：GetInstance()）

除此之外，还有一些关键点（需要多加注意，很容易忽视）：

  • 线程安全（双检锁 - DCL，即：double-checked locking）

  • 资源释放

4.单例模式的实现

4.1 单例 - 懒汉式（非线程安全）

在这种实现中，实例在第一次调用 GetInstance 时创建。由于没有线程安全机制，这种方式不适用于多线程环境。

#include <iostream>

class Singleton {
public:
    static Singleton* GetInstance();

private:
    Singleton() {}  // 构造函数（私有）
    static Singleton* p;  // 指向单例对象的指针
};

// 初始化静态成员变量
Singleton* Singleton::p = nullptr;

// 获取单例实例
Singleton* Singleton::GetInstance() {
    if (p == nullptr) {
        p = new Singleton();
    }
    return p;
}

int main() {
    Singleton* instance1 = Singleton::GetInstance();
    Singleton* instance2 = Singleton::GetInstance();
    std::cout << (instance1 == instance2) << std::endl;  // 输出1，两个实例是相同的
    return 0;
}

懒汉式的特点：

  • Lazy 初始化

  • 非多线程安全

优点：第一次调用才初始化，避免内存浪费。

缺点：必须加锁（在“线程安全”部分分享如何加锁）才能保证单例，但加锁会影响效率。  

4.2 单例 - 饿汉式（线程安全）

在这种实现中，单例对象在类加载时就被创建，确保了线程安全，但可能导致启动时的资源浪费。

#include <iostream>

class Singleton {
public:
    static Singleton* GetInstance();

private:
    Singleton() {}  // 构造函数（私有）
    static Singleton* p;  // 指向单例对象的指针
};

// 初始化静态成员变量
Singleton* Singleton::p = new Singleton();  // 在类加载时就创建实例

// 获取单例实例
Singleton* Singleton::GetInstance() {
    return p;
}

int main() {
    Singleton* instance1 = Singleton::GetInstance();
    Singleton* instance2 = Singleton::GetInstance();
    std::cout << (instance1 == instance2) << std::endl;  // 输出1，两个实例是相同的
    return 0;
}

饿汉式的特点：

  • 非 Lazy 初始化

  • 多线程安全

优点：没有加锁，执行效率会提高。

缺点：类加载时就初始化，浪费内存。

4.3 单例 - 懒汉式（双重检查锁，线程安全）

这种实现使用双重检查锁定（DCL）机制来确保线程安全，并且仅在需要时才创建单例对象。

#include <iostream>
#include <mutex>

class Singleton {
public:
    static Singleton* GetInstance();

private:
    Singleton() {}  // 构造函数（私有）
    static Singleton* p;  // 指向单例对象的指针
    static std::mutex m_mutex;  // 互斥锁，用于线程安全
};

// 初始化静态成员变量
Singleton* Singleton::p = nullptr;
std::mutex Singleton::m_mutex;

// 获取单例实例
Singleton* Singleton::GetInstance() {
    if (p == nullptr) {  // 第一次检查
        std::lock_guard<std::mutex> lock(m_mutex);  // 锁定互斥量
        if (p == nullptr) {  // 第二次检查
            p = new Singleton();
        }
    }
    return p;
}

int main() {
    Singleton* instance1 = Singleton::GetInstance();
    Singleton* instance2 = Singleton::GetInstance();
    std::cout << (instance1 == instance2) << std::endl;  // 输出1，两个实例是相同的
    return 0;
}

需要进行两次检验的原因：

第一次判断是为了验证是否创建对象，第二次判断是为了避免重复创建单例，因为可能会存在多个线程通过了第一次判断在等待锁，进 而创建新的实例对象。

  • 当A与B同时调用GetInstance时，判断第一个if都为空，这时A拿到锁，进行第二层if判断，条件成立new了一个对象；

  • B在外层等待，A创建完成，释放锁，B拿到锁，进行第二层if判断，条件不成立，结束释放锁；

  • C调用GetInstance时第一层判断不成立，直接拿到singleton对象返回，避免进入锁，减少性能开销。

4.4单例 - 局部静态变量实现

#include <iostream>

class Singleton {
public:
    // 获取单例实例
    static Singleton& GetInstance() {
        static Singleton instance;  // 局部静态变量
        return instance;
    }

    // 禁止拷贝构造函数和赋值运算符
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;

    // 示例方法
    void ShowMessage() const {
        std::cout << "Singleton instance address: " << this << std::endl;
    }

private:
    Singleton() {}  // 私有构造函数
};

int main() {
    Singleton& instance1 = Singleton::GetInstance();
    Singleton& instance2 = Singleton::GetInstance();
    
    instance1.ShowMessage();  // 输出单例对象的地址
    instance2.ShowMessage();  // 输出单例对象的地址

    // 验证两个实例是相同的
    std::cout << "Are both instances the same? " << ( &instance1 == &instance2 ) << std::endl;  // 输出1，两个实例是相同的

    return 0;
}

在这种实现中，单例对象是静态局部变量，只有在首次调用 GetInstance 时才会被创建。由于局部静态变量的初始化是线程安全的，这种方式不需要额外的锁机制来确保线程安全。

5.单例模式的资源释放

5.1使用局部静态变量（自动释放）

#include <iostream>

class Singleton {
public:
    static Singleton& GetInstance() {
        static Singleton instance;  // 局部静态变量
        return instance;
    }

    // 禁止拷贝构造函数和赋值运算符
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;

    // 示例方法
    void ShowMessage() const {
        std::cout << "Singleton instance address: " << this << std::endl;
    }

private:
    Singleton() {
        std::cout << "Singleton created" << std::endl;
    }
    ~Singleton() {
        std::cout << "Singleton destroyed" << std::endl;
    }
};

int main() {
    Singleton& instance1 = Singleton::GetInstance();
    instance1.ShowMessage();
    return 0;
}

5.2显式释放资源（使用懒汉式）

要手动释放资源，添加一个 static 函数，编写需要释放资源的代码，然后在需要释放的时候，手动调用该函数。

#include <iostream>

class Singleton {
public:
    static Singleton* GetInstance() {
        if (p == nullptr) {
            p = new Singleton();
        }
        return p;
    }

    static void DestroyInstance() {
        if(p != nullpter){
            delete p;
            p = nullptr;
        }
    }

    // 禁止拷贝构造函数和赋值运算符
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;

    // 示例方法
    void ShowMessage() const {
        std::cout << "Singleton instance address: " << this << std::endl;
    }

private:
    Singleton() {
        std::cout << "Singleton created" << std::endl;
    }
    ~Singleton() {
        std::cout << "Singleton destroyed" << std::endl;
    }

    static Singleton* p;  // 指向单例对象的指针
};

// 初始化静态成员变量
Singleton* Singleton::p = nullptr;

int main() {
    Singleton* instance1 = Singleton::GetInstance();
    instance1->ShowMessage();

    // 显式释放单例对象
    Singleton::DestroyInstance();
    return 0;
}

5.3 使用嵌套类进行资源释放

#include <iostream>

using namespace std;

class Singleton
{
public:
    // 获取单例实例
    static Singleton* GetInstance();

private:
    Singleton() {
        cout << "Singleton created" << endl;
    }  // 构造函数（私有）

    // 嵌套类，用于管理资源释放
    class GC
    {
    public:
        ~GC()
        {
            // 在析构函数中销毁单例对象
            if (m_pSingleton != nullptr) {
                cout << "Here destroy the m_pSingleton..." << endl;
                delete m_pSingleton;
                m_pSingleton = nullptr;
            }
        }
        static GC gc;  // 静态成员，用于在程序结束时自动销毁单例对象
    };

    static Singleton* m_pSingleton;  // 指向单例对象的指针
};

// 初始化静态成员
Singleton* Singleton::m_pSingleton = nullptr;
Singleton::GC Singleton::GC::gc;  // 实例化 GC 类的静态成员

// 获取单例实例
Singleton* Singleton::GetInstance()
{
    if (m_pSingleton == nullptr)
    {
        m_pSingleton = new Singleton();
    }
    return m_pSingleton;
}

int main()
{
    // 获取并使用单例实例
    Singleton* instance1 = Singleton::GetInstance();
    Singleton* instance2 = Singleton::GetInstance();

    cout << "Are both instances the same? " << (instance1 == instance2) << endl;  // 输出1，两个实例是相同的

    // 当程序结束时，`GC` 的析构函数会被调用，自动释放单例对象的资源
    return 0;
}

CodeNest
关注
  • 12
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++实现 单例模式实例详解
08-30
C++实现单例模式实例详解 单例模式是一种常用的设计模式，旨在确保某个类只有一个实例，并提供一个全局访问点来访问该实例。在C++中，实现单例模式有多种方式，今天我们将详细解释经典实现、懒汉模式、饿汉模式和...
C++设计模式-单例模式
06-13
李建忠老师的设计模式-单例模式讲解，示例以C++编程语言呈现。
C++ 单例模式的详解及实例
08-29
单例模式是设计模式中的一种，它的核心思想是限制类的实例化，确保一个类只有一个实例，并提供一个全局访问点。在C++中，单例模式通常用于创建那些需要在整个应用程序生命周期内只被创建一次的对象，例如日志系统、...
【C++】链表
qq_38801607的博客
08-22 792
链表是一种常见的动态数据结构，与数组相比，它在插入和删除操作中具有更高的效率。链表的每个元素称为节点（Node），节点包含两个部分：数据域（存储数据）和指针域（指向下一个节点的指针）。链表的最大特点是节点的内存位置不需要连续，可以通过指针来链接在一起。
C++ 重载运算符和重载函数
lly202406的博客
08-25 672
在C++编程语言中，运算符重载和函数重载是两个非常核心的概念，它们允许开发者扩展或重新定义运算符和函数的行为，以适应特定的数据类型或对象。本文将详细探讨C++中的运算符重载和函数重载，包括它们的基本概念、使用场景、实现方式以及注意事项。
C语言破墙镐对称飞迷宫
qq_69383179的博客
08-22 1521
这里有我用C语言编译的破墙镐对称飞迷宫和与之相关的一些东西
C++ 基础
weixin_51883798的博客
08-22 287
MyClass&& other:这是一个右值引用参数，指向要移动的对象。右值引用允许我们访问即将被销毁的对象，从中“窃取”资源。该关键字表示移动构造函数不会抛出异常。这是一个优化提示，告诉编译器在需要时可以安全地使用移动构造函数。这是C++11标准中新引入的一个特性，旨在提高性能，尤其是在涉及临时对象和资源管理时。特殊的成员函数，允许将一个对象的状态转移到另一个新创建的对象中，不需要进行复制。
c语言用if语句制作点单程序
2301_81968528的博客
08-20 452
printf("数字1代表喝咖啡，数字2代表喝雪碧:");这里的点单程序是用户输入相应的数字自动出来相应的饮品。puts("您要喝的是咖啡");puts("您要喝雪碧");比如输入1是咖啡，输入2是雪碧。c语言里面，if语句的语法是。
初识顺序表---C语言
weixin_74202161的博客
08-23 493
顺序表是一种以数组为基础的结构，对数组进行封装，实现常用的增删改查等操作的。//销毁。
C语言程序设计（初识C语言后部分）
2402_85207276的博客
08-24 778
·数组 ·冒泡排序算法
Linux编程： 使用 C++ 监控进程和线程的 CPU 使用情况
Where there is life, there is hope.
08-25 622
在 Linux 系统中，监控进程和线程的 CPU 使用情况可以帮助我们找出系统瓶颈和性能热点。本文将介绍两种方法使用 C++ 来监控 Linux 系统中进程和线程的 CPU 使用情况。
Dijkstra(c++)
weixin_73378557的博客
08-24 593
迪杰斯特拉算法(Dijkstra)是由荷兰计算机科学家狄克斯特拉于1959年提出的，因此又叫狄克斯特拉算法。是从一个顶点到其余各顶点的最短路径算法，解决的是有权图中最短路径问题。迪杰斯特拉算法主要特点是从起始点开始，采用贪心算法的策略，每次遍历到始点距离最近且未访问过的顶点的邻接节点，直到扩展到终点为止。同时dijkstra算法主要用于解决单源最短路问题（边权为正数），其可以分为两种版本，两种版本各有用处，并不存在好坏之分，接下来我们用n代表点的数量，用m代表边的数量。
坐牢第三十天（c++）
m0_62828714的博客
08-27 692
提示并输入一个字符串，统计该字符串中字母个数、数字个数、空格个数、其他字符的个数 效果图：
C++：list篇
最新发布
2301_80894970的博客
08-27 769
我们可以看到，当erase后如果在对it迭代器进行操作，vs则会进行强制检查(根据编译环境不同，处理环境也不相同),则不允许再继续使用,如果想继续使用的话，C++同样也给出了方案，可以看到erase会返回一个迭代器，而返回的迭代器就是下一个链表的位置。那么从上面的begin与end可以看出，使用迭代器遍历list，仅仅只需要解引用迭代器以及++迭代器就能取得我们想要的值与让迭代器走向下一个节点，那么有没有想过一个问题，list的迭代器与vector这种类似数组的迭代器底层是否是一样的呢？
【C++】类与对象
2401_82855612的博客
08-24 410
C++编译器给每个非静态的成员函数增加了一个隐藏的指针参数即this指针让该指针指向当前对象(函数运行时调用该函数的对象)，在函数体中所有“成员变量”的操作，都是通过该指针去访问。只需要计算成员变量的大小（注意内存对齐），不需要计算成员函数的大小，无论定义多少对象，成员函数就只有一个是公用的. 编译器给了空类一个字节来唯一标识这个类的对象。如果嵌套了结构体的情况，嵌套的结构体对齐到自己的最大对齐数的整数倍处，结构体的整 体大小就是所有最大对齐数（含嵌套结构体的对齐数）的整数倍。
c++每日练习记录4-（递归思想）
qq_33867768的博客
08-23 203
递归的思想：反向思考一个问题，由简单推广到复杂，找到规律方程。类似于解决高次的微分方程问题。（暂时不能很好理解可以看。利用利用两个新的指针，一个用于保存输出的初始节点，另外一个用于地址的迭代指向。
C++：类和对象（二）
Harper.Lee的博客
08-27 680
本篇博客介绍内容：构造函数、析构函数、拷贝构造函数、运算符重载和赋值运算符重载，以及一些细节例如：深浅拷贝、传值返回与传引用返回、传值传参与传引用传参等！
8月27c++
A111222129的博客
08-27 91
提示并输入一个字符串，统计字符串中字母、数字、空格和其他字符的个数。
CSP-CCF 201412-2 Z字形扫描
2301_79705447的博客
08-24 404
这个题目花了我好长时间，原先打算硬算，但是那样的话就太太太太复杂了，然后静下心来找规律，还真是找到了一些，虽然也挺复杂的，但是比硬解要好些。tip：要擅长找规律、静下心来找规律。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值