C++设计模式2 单例模式

文章目录

• ​​1. 概念​​
• ​​2. 为什么使用单例模式​​
• ​​3. 实现单例步骤常用步骤​​
• ​​4. 示例(饿汉式和懒汉式)​​

• ​​4.1 单线程模式下的单例模式​​
• ​​4.2 多线程下的单例示例​​

1. 概念

单例模式是一种对象创建型模式，使用单例模式，可以保证为一个类只生成唯一的实例对象。
也就是说，在整个程序空间中，该类只存在一个实例对象。

2. 为什么使用单例模式

在应用系统开发中，我们常常有以下需求：

1. 在多个线程之间，比如初始化一次socket资源；比如servlet环境，共享同一个资源或者操作同一个对象
2. 在整个程序空间使用全局变量，共享资源
3. 大规模系统中，为了性能的考虑，需要节省对象的创建时间等等。
   因为Singleton模式可以保证为一个类只生成唯一的实例对象，所以这些情况，Singleton模式就派上用场了。

3. 实现单例步骤常用步骤

1. 构造函数私有化
2. 提供一个全局的静态方法（全局访问点）
3. 在类中定义一个静态指针，指向本类的变量的静态变量指针

4. 示例(饿汉式和懒汉式)

4.1 单线程模式下的单例模式

#include <iostream>
using namespace std;
// 控制这个A类对象个数, 系统只有一个对象
class A{
private:
    A(){} // 构造函数私有, 这样就不能使用new A来生成对象了, 否则会报错
    // A* a; // 为了防止外部创建A对象, 直接在private创建自己的对象
    // A* getInstace(){return a;}
    // 使用静态成员去调用, 否则因为private构造对象, 调用getInstace会出错的
    static A* a;
public:
    static A* getInstace(){return a;} // 这样在主函数中直接使用A::getInstace()拿到对象a
};

A* A::a = NULL;

// 实现单例的步骤
// 1. 构造函数私有化
// 2. 增加静态私有的当前类的静态指针
// 3. 提供静态的对外接口

// 懒汉模式的单例模式
class Singleton_lazy{
private:
    static Singleton_lazy* pSingleton;
    Singleton_lazy(){cout<< "我是懒汉构造的..."<<endl;}
    static Singleton_lazy* getInstace(){
        if(pSingleton == NULL){  // 只有第一次调用的时候, 才会new一个对象出来
            pSingleton = new Singleton_lazy();
        }
        cout<<"懒汉式返回一个单例"<<endl;
        return pSingleton;
    }
};
Singleton_lazy* Singleton_lazy::pSingleton = NULL; // 类外初始化

// 饿汉式的单例模式
class Singleton_hungry{
private:
    Singleton_hungry(){cout<< "我是饿汉构造的..."<<endl;}
    static Singleton_hungry* pSingleton;
    static Singleton_hungry* getInstace(){
        cout<<"饿汉式返回一个单例"<<endl;
        return pSingleton;
    }
};
Singleton_hungry* Singleton_hungry::pSingleton = new Singleton_hungry; // 初始化的时候就创建了 

int main(int argc, char const *argv[])
{
    // A* a = new A; // 这是错误的
    A* a = A::getInstace();

    cout<<"hello"<<endl;
    return 0;
}

4.2 多线程下的单例示例