C++_16_单例模式

单例模式

概述：24 设计模式之一

设计模式： 程序员堆特定问题提出的一种解决方案，也是最优方案

单例模式：

​ 解决的问题：只允许这个类 创建 一个对象

实现思路：

• 1 私有化 构造函数 与 拷贝构造 【防止通过拷贝与构造创建对象】
• 2 通过公共的静态函数，该函数返回该类的唯一对象

代码实现：

• 懒汉式 多线程下是不安全的 内存占用少 需要才创建

• 饿汉式 多线程下是安全的 但是占内存多 直接就先创建备着

• 单线程下 两者没区别

• 无论那种 单例模式 步骤都是

  • 1 私有化 构造函数 与 拷贝构造 【防止通过拷贝与构造创建对象】
  • 2 通过公共的静态函数，该函数返回该类的唯一对象

懒汉式：

【需要才创建】

• 懒汉式：

#include <iostream>
using namespace std;
//       懒汉式   多线程是不安全的
class A
{
private:
    // 写法1 ：
    //   static A a;
    static A *a; //  因为是静态成员  所以需要类外初始化
    A()
    {
    } // 自己写无参 就不会使用系统提供的  来创建对象  而是使用自己的
    //  因为拷贝构造也会创建对象  所以也私有  这样 就不能通过 构造和拷贝来创建对象了
    A(const A &a)
    {
    }

public:
    static A *getInstance() // 返回该类的唯一对象  静态函数 只能使用静态成员变量  所以去创建 静态成员变量并类外定义
    {
        // static A* a; 这创建 就每次都创建了
        if (a == NULL) // 看有对象就返回 没有就创建
        {
            a = new A();
        }
        return a;
    }
};
// 静态的需要 类外定义
// 写法1 定义
//  A A::a;
A *A::a = NULL;   //创建对象 使用指针 先置空取判断 为空创建  
// 类名 *类名::对象指针  
int main(int argc, char const *argv[])
{
    A *a1 = A::getInstance();
    A *a2 = A::getInstance();
    A *a3 = A::getInstance();
    cout << a1 << endl;
    cout << a2 << endl;
    cout << a3 << endl;
    return 0;
}

饿汉式：

【准备着等取】

• 饿汉式： 先备着 安全但是占内存 先创建好 类的对象 备着 不管用不用

#include <iostream>
using namespace std;
            //  饿汉式  多线程线程是安全的  但是占内存多
class A
{
    static A a; //静态成员创建    但是静态成员需要去类外初始化
    private:
    	A()
        { }   // 自己写无参 就不会使用系统提供的  来创建对象  而是使用自己的
    //  因为拷贝构造也会创建对象  所以也私有  这样 就不能通过 调用构造和拷贝来创建对象了
      	A(const A &a)
        { }
    public:
    	static A& getInstance()  // 返回A 引用 或者 直接返回本身 目的就是返回地址  static A getInstance()
        //静态函数只能使用静态成员  所以需要去定义静态成员
        { 
           return a; 
        }
};
A A::a;  //A 就创建好了
int main(int argc, char const *argv[])
{ 
    //引用操作
    A& a1 =A::getInstance();
    A& a2 =A::getInstance();
    A& a3 =A::getInstance();
    //取地址操作
    cout<<&a1<<endl;
    cout<<&a2<<endl;
    cout<<&a3<<endl;
    return 0;
}

程序弊端 哪怕没需要使用到 A类 对象 但是已经创建了 所以一直占用内存