C++11单例模式

🐶博主主页：@ᰔᩚ. 一怀明月ꦿ 

❤️‍🔥专栏系列：线性代数，C初学者入门训练，题解C，C的使用文章，「初学」C++，linux

🔥座右铭：“不要等到什么都没有了，才下定决心去做”

🚀🚀🚀大家觉不错的话，就恳求大家点点关注，点点小爱心，指点指点🚀🚀🚀

目录

单例模式

单例模式通常包含以下几个要素

饿汉模式

使用方法

懒汉模式

使用方法

---

单例模式

单例模式是一种设计模式，其核心思想是确保一个类只有一个实例

单例模式通常包含以下几个要素

私有的构造函数（Private Constructor）： 单例类的构造函数通常是私有的，这样外部就无法直接实例化该类。

静态成员变量（Static Member Variable）： 单例类通常包含一个静态成员变量，用于存储唯一的实例。

静态访问方法（Static Access Method）： 单例类提供一个静态的访问方法，用于获取该类的实例。如果该类的实例不存在，则在该方法内部创建一个新的实例，并返回给调用者。

延迟初始化（Lazy Initialization）： 单例模式通常采用延迟初始化的方式来创建实例，即在第一次访问时才创建实例，而不是在类加载时就创建实例。

线程安全性（Thread Safety）： 如果单例模式在多线程环境下使用，需要考虑实现线程安全的方式来确保只有一个实例被创建。

饿汉模式

饿汉模式是单例模式的另一种实现方式，与懒汉模式相反，饿汉模式在类加载时就创建了单例对象，而不是等到首次被调用时才进行实例化。因此，无论是否需要使用该单例对象，饿汉模式都会在程序启动时进行实例化。

饿汉模式通常采用以下方式实现：

私有构造函数： 将类的构造函数设置为私有，防止外部直接实例化该类。
 
静态成员变量： 在类中声明一个静态成员变量，并在声明时直接进行实例化。
 
静态获取方法： 提供一个静态的公有方法，用于获取单例对象的实例。在该方法
中直接返回预先创建好的单例对象。

注意：饿汉模式的实现相对简单，不需要考虑线程安全性，因为在类加载时就已经创建了单例对象，不会存在多线程竞争创建实例的情况。因此，饿汉模式通常是线程安全的。

使用方法

1）构造函数设为私有
2）instance//单例为静态成员变量，类内声明，类外初始化static 类名* instance
类名* 类名::instance=new 类名();//类外定义
3)创建对外接口，通过这个获取单例
Static 类名* getinstance()
{
    return instance;
}

事例：

class A
{
public:
    
    static A* GetInstance()
    {
        return _inst;
    }
    
    void add(const string& str)
    {
        _dict[str]++;
    }
    void print()
    {
        for(auto& e:_dict)
        {
            cout<":"<
        }
    }
private:
    A(){}
    
    mapint> _dict;
    int _n=0;
    static A* _inst;//静态成员是属于类的，不属于对象的
};
A* A::_inst=new A();//提前创建对象
 
优点：实现简单
缺点：可能导致进程启动慢，如果两个单例有启动先后顺序，那么饿汉无法控制

懒汉模式

懒汉模式是单例模式的一种实现方式，其特点是在首次被调用时才会创建单例对象。懒汉模式延迟了单例对象的实例化，直到第一次被使用时才进行实例化。

懒汉模式通常采用以下方式实现：

私有构造函数： 将类的构造函数设置为私有，防止外部直接实例化该类。
 
静态成员变量： 在类中声明一个静态成员变量，用于保存单例对象的实例。
 
静态获取方法： 提供一个静态的公有方法，用于获取单例对象的实例。在该方法中，
判断单例对象是否已经被创建，如果没有则进行实例化并返回，如果已经被创建则直接返回已有的实例。

注意：懒汉模式的实现中需要考虑多线程环境下的线程安全性，因为在多线程环境下，可能会出现多个线程同时判断单例对象是否为空，导致多次创建实例的问题。

使用方法

1）构造函数设为私有
2）instance//单例为静态成员变量，类内声明，类外初始化static 类名* instance
类名* 类名::instance=nullptr;//类外定义
3）创建对外接口，通过这个获取单例
Static 类名* getinstance()
{
    //这里为什么要用俩个if呢？因为我们在内层if进行加锁了，加锁为了保证只有一个线程去创建单例。其实可以把锁加在外层if，但是这样会导致每个线程都会去申请锁，这样导致资源浪费，所以我们把锁加在内层的if，只要有一个线程创建了单例，那其他线程就不会进入到内层if
    if(instance==nullptr)
    {
         //这里可以加一把锁
         if(instance==nullptr)
        {
            instance=new 类名();
        }
        //解锁
    }
    return instance;
}

事例

懒汉模式：第一次使用的时候再创建
//new的懒汉对象一般不需要释放
class B
{
public:
    
    static B* GetInstance()
    {
        if(_inst==nullptr)
        {
            _inst=new B;
        }
        return _inst;
    }
    
    void add(const string& str)
    {
        _dict[str]++;
    }
    void print()
    {
        for(auto& e:_dict)
        {
            cout<":"<
        }
    }
private:
    B(){}
    
    mapint> _dict;
    int _n=0;
    static B* _inst;//静态成员是属于类的，不属于对象的
};
B* B::_inst;
 
int main()
{
    B::GetInstance()->add("苹果");
    B::GetInstance()->add("苹果");
    B::GetInstance()->add("葡萄");
    
    B::GetInstance()->print();
    return 0;
}
优点：启动快
缺点：存在线程安全

 🌸🌸🌸如果大家还有不懂或者建议都可以发在评论区，我们共同探讨，共同学习，共同进步。谢谢大家！ 🌸🌸🌸