单例模式（创建型设计模式）的 C++ 代码示例模板

已于 2023-12-18 20:19:34 修改
阅读量86 收藏
点赞数
分类专栏： 设计模式 文章标签： 单例模式 单例模式（饿汉式） 单例模式（懒汉式） 设计模式 C++
于 2023-11-21 10:24:21 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_62083249/article/details/134515065
版权

文章目录

前言

单例模式（创建型设计模式）的 C++ 代码示例模板。

代码仓库

单例模式（Singleton）

结构

  • 单例类
  • 私有静态单例对象
  • 私有构造方法
  • 公有静态获取单例对象方法

返回引用的原因：保证是同一单例对象而不是副本；减少返回值的拷贝开销；返回值拷贝被删除

  • 私有或删除拷贝构造方法和拷贝赋值运算符

设置为私有：允许类内将单例对象作为参数或返回值传递（公有静态获取单例对象方法 可以返回值而不是引用）
设置为删除：禁止拷贝
设置为私有和删除：禁止拷贝

核心

  • 私有静态单例对象：单例类内保存同一单例对象
  • 私有构造方法：禁止客户端创建多个单例对象
  • 公有静态获取单例对象方法：允许客户端创建或获取同一单例对象

一般 饿汉式是获取，懒汉式是创建或获取。

  • 私有或删除拷贝构造方法和拷贝赋值运算符：禁止客户端或单例类内创建一个或多个拷贝单例对象

类型

  • 饿汉式
  • 懒汉式

饿汉式

  • 程序启动时（main() 执行前） 创建单例对象（不管用不用都提前创建）
  • 在类外初始化私有静态单例对象（保证在程序启动时（main() 执行前）创建单例对象）

在类外初始化私有静态单例对象 注意：
静态非 const 整数类型（short 和 int 等） 或 静态非 constexpr 内置类型（char 和 float 等）的成员属性 只能在类外初始化；
因为构造方法是私有权限，所以在类外只能是隐式调用无参构造方法；
如果单例类需要传参并初始化成员属性，可以考虑额外 定义设置成员属性方法 或 在公有静态获取单例对象方法中设置成员属性

  • 线程安全
  • 公有静态获取单例对象方法直接返回单例对象（因为在程序启动时（main() 执行前）已经创建单例对象，且线程安全，无需其他逻辑）
  • 创建或获取单例对象时使用引用

使用引用的原因：保证是同一单例对象而不是副本；减少返回值的拷贝开销；返回值拷贝被删除

代码（普通版）

// 饿汉式：程序启动时（main() 执行前） 创建单例对象（不管用不用都提前创建）
#include <iostream>

using std::cout;
using std::endl;

class Singleton
{
public:
    // 公有静态获取单例对象方法
    inline static Singleton &getInstance() // 返回引用的原因：保证是同一单例对象而不是副本；减少返回值的拷贝开销；返回值拷贝被删除
    {
        return singleton; // 直接返回单例对象：因为在程序启动时（main() 执行前）已经创建单例对象，且线程安全，无需其他逻辑
    }

private:
    // 私有构造方法
    Singleton()
    {
        cout << "Singleton()" << endl;
    }

    // 私有或删除拷贝构造方法和拷贝赋值运算符
    // 设置为私有：允许类内将单例对象作为参数或返回值传递（公有静态获取单例对象方法 可以返回值而不是引用）
    // 设置为删除：禁止拷贝
    // 设置为私有和删除：禁止拷贝
    Singleton(const Singleton &) = delete;
    Singleton &operator=(const Singleton &) = delete;

    // 私有静态单例对象
    static Singleton singleton;
};

// 在类外初始化私有静态单例对象 注意：
// 静态非 const 整数类型（short 和 int 等） 或 静态非 constexpr 内置类型（char 和 float 等）的成员属性 只能在类外初始化
// 因为构造方法是私有权限，所以在类外只能是隐式调用无参构造方法
// 如果单例类需要传参并初始化成员属性，可以考虑额外 定义设置成员属性方法 或 在公有静态获取单例对象方法中设置成员属性
Singleton Singleton::singleton; // 隐式调用无参构造方法

// 客户端
int main()
{
    // 创建或获取单例对象
    Singleton &singleton_1 = Singleton::getInstance(); // 使用引用的原因：保证是同一单例对象而不是副本；减少返回值的拷贝开销；返回值拷贝被删除
    Singleton &singleton_2 = Singleton::getInstance();

    // 输出单例对象地址：地址相同，说明是同一单例对象
    cout << "Singleton_1: " << &singleton_1 << endl;
    cout << "Singleton_2: " << &singleton_2 << endl;

    return 0;
}
/*
输出：
Singleton()
Singleton_1: 0x407030
Singleton_2: 0x407030
*/

代码

// 饿汉式：程序启动时（main() 执行前） 创建单例对象（不管用不用都提前创建）
#include <iostream>

using std::cout;
using std::endl;

// 单例类
class Singleton
{
public:
    ~Singleton() = default;

    // 公有静态获取单例对象方法
    inline static Singleton &getInstance() // 返回引用的原因：保证是同一单例对象而不是副本；减少返回值的拷贝开销；返回值拷贝被删除
    {
        return singleton; // 直接返回单例对象：因为在程序启动时（main() 执行前）已经创建单例对象，且线程安全，无需其他逻辑
    }

private:
    // 私有构造方法
    Singleton()
    {
        cout << "Singleton()" << endl;
    }

    // 私有或删除拷贝构造方法和拷贝赋值运算符
    // 设置为私有：允许类内将单例对象作为参数或返回值传递（公有静态获取单例对象方法 可以返回值而不是引用）
    // 设置为删除：禁止拷贝
    // 设置为私有和删除：禁止拷贝
    Singleton(const Singleton &) = delete;
    Singleton &operator=(const Singleton &) = delete;

    // 私有静态单例对象
    static Singleton singleton;
};

// 在类外初始化私有静态单例对象 注意：
// 静态非 const 整数类型（short 和 int 等） 或 静态非 constexpr 内置类型（char 和 float 等）的成员属性 只能在类外初始化
// 因为构造方法是私有权限，所以在类外只能是隐式调用无参构造方法
// 如果单例类需要传参并初始化成员属性，可以考虑额外 定义设置成员属性方法 或 在公有静态获取单例对象方法中设置成员属性
Singleton Singleton::singleton; // 隐式调用无参构造方法

// 客户端
int main()
{
    // 创建或获取单例对象
    Singleton &singleton_1 = Singleton::getInstance(); // 使用引用的原因：保证是同一单例对象而不是副本；减少返回值的拷贝开销；返回值拷贝被删除
    Singleton &singleton_2 = Singleton::getInstance();

    // 输出单例对象地址：地址相同，说明是同一单例对象
    cout << "Singleton_1: " << &singleton_1 << endl;
    cout << "Singleton_2: " << &singleton_2 << endl;

    return 0;
}
/*
输出：
Singleton()
Singleton_1: 0x407030
Singleton_2: 0x407030
*/

懒汉式

  • 程序运行时创建单例类对象（需要用了才创建）
  • 在类外初始化私有静态单例对象 和 私有静态互斥锁（保证在程序运行时创建单例类对象）

在类外初始化私有静态单例对象 和 私有静态互斥锁 注意：
静态非 const 整数类型（short 和 int 等） 或 静态非 constexpr 内置类型（char 和 float 等）的成员属性 只能在类外初始化；
因为构造方法是私有权限，所以在类外只能是隐式调用无参构造方法；
如果单例类需要传参并初始化成员属性，可以考虑额外 定义设置成员属性方法 或 在公有静态获取单例对象方法中设置成员属性

  • 线程不安全（如多个线程同时调用公有静态获取单例对象方法）
  • 公有静态获取单例对象方法使用 私有静态互斥锁 和 双重检查锁定（保证线程安全）
  • 创建或获取单例对象时使用引用

使用引用的原因：保证是同一单例对象而不是副本；减少返回值的拷贝开销；返回值拷贝被禁止

代码（普通版）

// 懒汉式：程序运行时创建单例类对象（需要用了才创建）
#include <iostream>
#include <mutex>

using std::cout;
using std::endl;
using std::lock_guard;
using std::mutex;

// 单例类
class Singleton
{
public:
    // 注意：静态对象由程序管理，不需要析构方法
    // ~Singleton()
    // {
    //     delete singleton;
    // }

    // 公有静态获取单例对象方法
    static Singleton &getsingleton() // 返回引用的原因：保证是同一单例对象而不是副本；减少返回值的拷贝开销；返回值拷贝被删除
    {
        // 线程不安全（如多个线程同时调用公有静态获取单例对象方法）
        // 使用 私有静态互斥锁 和 双重检查锁定（保证线程安全）
        if (singleton == nullptr) // 第一重检查锁定
        {
            lock_guard<mutex> mutex_lock_guard(mutex_lock); // 上锁

            // 第二次检查，确保在互斥锁区域内再次检查单例对象是否未创建
            if (singleton == nullptr) // 第二重检查锁定
            {
                singleton = new Singleton();
            }

            // 隐式解锁
        }

        return *singleton;
    }

private:
    // 私有构造方法
    Singleton()
    {
        cout << "Singleton()" << endl;
    }

    // 私有或删除拷贝构造方法和拷贝赋值运算符
    // 设置为私有：允许类内将单例对象作为参数或返回值传递（公有静态获取单例对象方法 可以返回值而不是引用）
    // 设置为删除：禁止拷贝
    // 设置为私有和删除：禁止拷贝
    Singleton(const Singleton &) = delete;
    Singleton &operator=(const Singleton &) = delete;

    // 私有静态单例对象
    static Singleton *singleton;

    // 私有静态互斥锁
    static mutex mutex_lock;
};

// 在类外初始化私有静态单例对象为空 和 私有静态互斥锁 注意：
// 静态非 const 整数类型（short 和 int 等） 或 静态非 constexpr 内置类型（char 和 float 等）的成员属性 只能在类外初始化
// 因为构造方法是私有权限，所以在类外只能是隐式调用无参构造方法
// 如果单例类需要传参并初始化成员属性，可以考虑额外 定义设置成员属性方法 或 在公有静态获取单例对象方法中设置成员属性
Singleton *Singleton::singleton = nullptr;
mutex Singleton::mutex_lock;

// 客户端
int main()
{
    // 创建或获取单例对象
    Singleton &singleton_1 = Singleton::getsingleton(); // 使用引用的原因：保证是同一单例对象而不是副本；减少返回值的拷贝开销；返回值拷贝被禁止
    Singleton &singleton_2 = Singleton::getsingleton();

    // 输出单例对象地址：地址相同，说明是同一单例对象
    cout << "Singleton_1: " << &singleton_1 << endl;
    cout << "Singleton_2: " << &singleton_2 << endl;

    return 0;
}
/*
输出：
Singleton()
Singleton_1: 0x2502500
Singleton_2: 0x2502500
*/

代码

// 懒汉式：程序运行时创建单例类对象（需要用了才创建）
#include <iostream>
#include <memory>
#include <mutex>

using std::cout;
using std::endl;
using std::lock_guard;
using std::make_unique;
using std::mutex;
using std::unique_ptr;

// 单例类
class Singleton
{
public:
    ~Singleton() = default;

    // 公有静态获取单例对象方法
    static Singleton &getsingleton() // 返回引用的原因：保证是同一单例对象而不是副本；减少返回值的拷贝开销；返回值拷贝被删除
    {
        // 线程不安全（如多个线程同时调用公有静态获取单例对象方法）
        // 使用 私有静态互斥锁 和 双重检查锁定（保证线程安全）
        if (singleton == nullptr) // 第一重检查锁定
        {
            lock_guard<mutex> mutex_lock_guard(mutex_lock); // 上锁

            if (singleton == nullptr) // 第二重检查锁定
            {
                // make_unique<> 是非成员函数模板，不是类的成员，即使在类内也不能访问类内私有成员，需要声明为友元
                singleton = make_unique<Singleton>();
            }

            // 隐式解锁
        }

        return *singleton;
    }

private:
    // 私有构造方法
    Singleton()
    {
        cout << "Singleton()" << endl;
    }

    // 私有或删除拷贝构造方法和拷贝赋值运算符
    // 设置为私有：允许类内将单例对象作为参数或返回值传递（公有静态获取单例对象方法 可以返回值而不是引用）
    // 设置为删除：禁止拷贝
    // 设置为私有和删除：禁止拷贝
    Singleton(const Singleton &) = delete;
    Singleton &operator=(const Singleton &) = delete;

    // 私有静态单例对象
    static unique_ptr<Singleton> singleton;

    // 私有静态互斥锁
    static mutex mutex_lock;

    // 声明 make_unique<> 为友元
    friend unique_ptr<Singleton> make_unique<Singleton>();
};

// 在类外初始化私有静态单例对象为空 和 私有静态互斥锁 注意：
// 静态非 const 整数类型（short 和 int 等） 或 静态非 constexpr 内置类型（char 和 float 等）的成员属性 只能在类外初始化
// 因为构造方法是私有权限，所以在类外只能是隐式调用无参构造方法
// 如果单例类需要传参并初始化成员属性，可以考虑额外 定义设置成员属性方法 或 在公有静态获取单例对象方法中设置成员属性
unique_ptr<Singleton> Singleton::singleton = nullptr;
mutex Singleton::mutex_lock;

// 客户端
int main()
{
    // 创建或获取单例对象
    Singleton &singleton_1 = Singleton::getsingleton(); // 使用引用的原因：保证是同一单例对象而不是副本；减少返回值的拷贝开销；返回值拷贝被禁止
    Singleton &singleton_2 = Singleton::getsingleton();

    // 输出单例对象地址：地址相同，说明是同一单例对象
    std::cout << "Singleton_1: " << &singleton_1 << std::endl;
    std::cout << "Singleton_2: " << &singleton_2 << std::endl;

    return 0;
}
/*
输出：
Singleton()
Singleton_1: 0x25624e0
Singleton_2: 0x25624e0
*/

总结

单例模式（创建型设计模式）的 C++ 代码示例模板。

参考资料

作者的话

  • 感谢参考资料的作者/博主
  • 作者：夜悊
  • 版权所有，转载请注明出处，谢谢~
  • 如果文章对你有帮助，请点个赞或加个粉丝吧，你的支持就是作者的动力~
  • 文章在描述时有疑惑的地方，请留言，定会一一耐心讨论、解答
  • 文章在认识上有错误的地方, 敬请批评指正
  • 望读者们都能有所收获
夜悊
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
如何在 C++ 中实现一个单例类模板
12-16
单例模式是最简单的设计模式之一。在实际工程中，如果一个类的对象重复持有资源的成本很高，且对外接口是线程安全的，我们往往倾向于将其以单例模式管理。 此篇我们在 C++ 中实现正确的单例模式。 选型 在 C++ 中，单例模式有两种方案可选。 一是实现一个没有可用的公开构造函数的基类，并提供 GetInstance 之类的静态接口，以便访问子类唯一的对象。由于子类构造必须调用基类构造，但基类无公开构造函数可用，这使得子类对象只能由基类及基类的友元来构造，从而在机制上保证单例。 二是实现一个类模板，其模板参数是希望由单例管理的类的名字，并提供 GetInstance 之类的静态接口。这种做法的
c++单例模式模板
waxtear的博客
02-05 2282
所有单例模类直接继承此模板即可，线程安全，效率高（无所），延时构造。 #include <iostream> using namespace std; template <typename T> class Singleton { public: //外部获取单例的接口 static T& getInstance() { stati...
C++单例模式模板
Kellygod
04-12 892
之前写毕业设计时用到的，现在把整个类抽出来方便以后继续用，非线程完全安全，想要完全线程安全，可以调用std::mutex，给它加把锁。class CDevice { public: static CDevice &getCDeviceInstance() { //静态变量初始化一次的特点 static CDevice mCDevice;
C++：单例模式 模板模式
m0_69414302的博客
07-10 1310
模板模式是定义一个算法流程，需要借助继承，将一些特定的步骤的具体实现延迟到子类，使得可以在不改变算法流程的情况下，通过不同的子类，来实现定制流程中的特定步骤。
C++单例模式与单例类模板
weixin_34128501的博客
09-06 188
1、单例模式（1）需求的提出：在架构设计时，某些类在整个系统生命周期中最多只能有一个对象存在(Single,Instance)（2）问题：如何定义一个类，使得这个类最多只能创建一个对象？要控制类的对象数目，必须对外隐藏构造函数思路： @1：将构造函数的访问属性设置为private，将拷贝构造函数，赋值操作符都声明成private的，防止对象的赋值操作，因为这个类的对象只能有一...
C++之单例类模板
weixin_43985500的博客
10-08 722
需求的提出 在架构设计时，某些类在整个系统生命周期中最多只能有一个对象存在（Single Instance） 要控制类的对象数目，必须对外隐藏构造函数； 思路： 1、将构造函数的访问属性设置为private 2、定义instance并初始化为NULL； 3、当需要使用对象时，访问instance的值 1）、空值：创建对象，并用instance标记； 2）、非空值：返回instance标记的对象。 实例分析1 #include <iostream> #include <string>
单例模式的 模板方式实现 c++
Guyf的专栏
09-18 1905
#ifndef SINGLETON_H#define SINGLETON_H#include templateclass singleton{public:static T& Instance(){if(!pInstance){pInstance = new T;}return *pInstance;}private:singleton();static T* pInstance;};templa
C++模板——单例类模板
食梦者
06-01 2639
本文参照于狄泰软件学院——《C++深度剖析课程》
C++ - 泛性编程单例类模板
weixin_49303682的博客
08-18 384
1.单例模式（设计模式） 在架构设计时，某些类在整个系统生命期中最多只能有一个对象存在(Single Instance)
C++ 单例模式的模板类 - 懒汉类型
Y_jay的博客
03-30 498
1、简单的单例模式类 class singleton{ private: singleton(); ~singleton(); singleton(const singleton&); singleton& operator=(const singleton&); public: static singleton* GetIns...
c++中的单例类模板的实现方法详解
01-20
1、什么是单例模式 　　在架构设计时，某些类在整个系统生命周期中最多只能有一个对象存在 （ Single Instance )。如超市收银系统，其外观主要由显示器（1个）、扫描枪（1个）、收款箱（1个）组成，在系统正常运行期间这三部分都是唯一存在的；也就是说，显示器、扫描枪、收款箱这三部分都应该有各自的类，并且每个类只能唯一地实例化一个对象，基于这种模式的程序设计，称为单例模式。 　　！！！单例模式只能创建一个对象，且该对象的生命周期伴随系统的整个运行期间。 2、怎么实现单例模式 　　思考：如何定义一个类，使得这个类最多只能创建一个对象？ 　　分析：因为对象是由构造函数创建的，所以我们应该
c++ 模板 模板类 以及 其单例模式的模板实现
weixin_44654161的博客
11-23 487
c++ 模板 模板类 以及 其单例模式应用
C++设计模式--单例模式(Singleton)及单例通用模板
luoyayun361的专栏
03-02 2099
概述 C++中的单例模式应该是最简单的了，并且非常常见，在编码中经常会用到。那么，简单的总结下 C++中的单例模式写法，以及根据单例模式扩展后的一些写法，最后还有单例的通用模板，可用于快捷创建一个单例类。 单例类 创建一个单例模式的关键是防止他人获得任何控制其对象生存期的权利，也就是说不要让别人可以随便创建类对象，单例类在整个程序生存周期中至始至终就只有一个对象，为了做到这一点，必须要先把构造函数...
C++ 设计模式3：单例模式
琅嬛福地
04-12 1670
单例 Singleton 是设计模式的一种，其特点是只提供唯一一个类的实例,具有全局变量的特点，在任何位置都可以通过接口获取到那个唯一实例;具体运用场景如：设备管理器，系统中可能有多个设备，但是只有一个设备管理器，用于管理设备驱动;数据池，用来缓存数据的数据结构，需要在一处写，多处读取或者多处写，多处读取;
C++单例模式模板 （简单易懂且有效）
为啥不吃肉捏 的博客
09-28 3892
单例模式几乎是最常用的设计模式，简单易懂，使用起来效果显著，在此也不对单例模式做剖析，不了解的可以自行查阅资料。 项目中多次使用单例模式后发现每次都是重复的构建单例类，于是做了一个单例模式的模板。 //单例模板 //delete 与 default 来自于 c++ 11 template <typename T> class Singleton { //使用默认构造和析构函数 Singleton() = default; ~Singleton() = default; p
C++单例模式模板类
xiaosier_D的博客
11-10 881
通过可变参数模板和友元函数实现双检测锁单例模式的模板类
C++ 单例模式 模版类(Meyers‘ Singleton)
xupeng1644的博客
10-23 3139
自己实现的Meyers’ Singleton的单例模式模板类。 template<typename T> class Singleton { public: ~Singleton() = default; static T& getInstance() // Meyers' Singleton { static T instance; return ins...
C++单例模板类
king3wade的博客
08-16 944
单例模式是保证一个类只有一个实例，并提供一个访问它的全局访问点，该实例被所有程序模块共享。 本文提供两种方式实现单例模板类：1、使用私有静态指针变量 2、使用局部静态变量， 具体如下： 1、私有静态指针变量 struct Uncloneable { protected: Uncloneable() {} ~Uncloneable(){} private: Uncloneable(const...
C++ 模板实现单例模式
m0_51551385的博客
06-06 849
一个通用性很强的单例模式实现
Java 实现单例模式的几种方法
最新发布
lt5227的博客
07-18 898
单例模式是一种常用的软件设计模式，其目的是确保一个类在任何情况下只有一个实例，并提供一个全局访问点供外部获取这个唯一的实例。这种模式特别适用于那些具有全局状态的场合，如配置管理器、线程池、缓存、对话管理等。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值