设计模式----单例模式

**剑指offer面试题2：

设计一个类，我们只能生成该类的一个实例。**

一、只适用于单线程环境:

1。利用静态成员函数—->设计思路：

1）因为只能产生一个示例—–>需将该类的构造函数的访问权限设置为私有的（不允许类外在任意地方可以实例化出该类对象）

2）因为静态成员变量是该类所有对象所共享的，内存中只有一份，所以就想到在类内声明一个指向该类对象的指针

3）因为类外不能实例化出该类对象，所以—>需要在类内定义一个静态的方法，返回指向该类对象的指针。

#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
using namespace std;

class Singleton
{
    Singleton()//将构造函数设置为private的，是为了防止在类外构造对象
    {
        cout << "Singleton" << endl;
    }
    static Singleton* _instance;//指向该类对象的指针
public:
    static Singleton* Get()//获取指向该类对象的指针,
        //因为在类外不能创建对象，所以要将该函数声明为static的,
        //使得在类外可以使用类的作用域限定符来获取
    {
          return _instance;
    }
};

Singleton* Singleton::_instance = new Singleton();//静态成员变量需要在类外进行定义

void Test()
{
    //Singleton tmp1;//证明不能在类外创建对象
    //Singleton tmp2 = new Singleton();
    Singleton* tmp3 = Singleton::Get();
    Singleton* tmp4 = Singleton::Get();

    cout << (tmp3 == tmp4) << endl;
}

int main()
{
    cout << "main()" << endl;
    Test();
    return 0;
}

设置断点：
在静态成员变量的定义处打断点；
在构造函数中打断点；
在测试程序的main函数开始处打断点；
通过调试：
会发现—->①程序运行开始后首先执行的是：定义静态成员变量，初始化静态成员变量时会去调用构造函数。
②定义并初始化静态成员变量后才进入了main函数。

根据输出结果：
我们也可以发现，调用两次Get函数的的返回值相同—–>这应该可以很好理解—静态成员变量只有一份呀~

我们都知道：静态成员变量在类中只存在一份，是所有对象所共享的。
那么也就是说该类只能实例化出一份，无论类外如何，在程序编译完成后这个实例已经存在了。

   这个设计方式的缺点是：无论你需不需要，都会存在一份类的实例，可我们有时候并不需要对象呀~~（这时就会浪费空间）。

2.实现按需创建实例：
尽可能晚的创建类的实例，—->实现资源的最大利用率

设计思路：
1）同样的，将构造函数设置为私有的—>防止在类外实例化对象；
2）声明一个静态的成员变量—->指向该对象的指针，并将其初始化为NULL;
3)在类中定义一个静态的方法，用于创建一个实例，当需要使用对象时，使用类的作用域限定符引用该静态方法
4）在静态方法内，当第一次引用该类对象时，构造该对象，当不是第一次引用该对象时，则直接返回第一次构造的对象地址（静态成员变量是该类所有对象共享的）。

代码如下：

#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
using namespace std;

class Singleton
{
    Singleton()//将构造函数设置为private的，是为了防止在类外构造对象
    {
        cout << "Singleton" << endl;
    }
    static Singleton* _instance;//指向该类对象的指针
public:
    static Singleton* Get()//获取指向该类对象的指针,
        //因为在类外不能创建对象，所以要将该函数声明为static的,
        //使得在类外可以使用类的作用域限定符来获取
    {
        if (NULL == _instance)
        {
            _instance = new Singleton();//保证了只创建一份实例
            cout << "creat once" << endl;
        }
          return _instance;
    }
};

Singleton* Singleton::_instance = NULL;//静态成员变量需要在类外进行定义

void Test()
{
    //Singleton tmp1;//证明不能在类外创建对象
    //Singleton tmp2 = new Singleton();
    Singleton* tmp3 = Singleton::Get();
    Singleton* tmp4 = Singleton::Get();

    cout << (tmp3 == tmp4) << endl;
}

int main()
{
    cout << "main()" << endl;
    Test();
    return 0;
}

输出结果：

从输出分析：
只有在第一次引用（判断静态成员变量是否为NULL）该静态方法时，才会去调用构造函数实例化对象。
如果不是第一次引用，就直接返回静态成员变量的值，不会再去创建对象了（保证该类只能创建一个实例）。

小结：
创建单例模式的类：
①将构造函数设置为私有的；
②声明一个静态成员变量（做返回值用）
③声明一个静态的方法

---

上述实现的单例模式还存在线程安全的问题。。。
假设现在有两个线程，线程①引用类的静态方法—>判断静态成员变量为NULL,这时线程①暂停，线程②也引用类的静态方法—>判断静态成员变量为NULL,创建对象（对象①），然后线程②暂停，线程①继续执行，创建对象（对象②）。——->这和单例模式的要求（只能创建一个对象）难道不是矛盾了吗？
所以为了保证在多线程环境下我们还是能够得到类型的一个实例，我们就需要为其加上一把同步锁。。。
目前我的能力只能到这，后面会续写加锁后的实现。

说明：看了一篇博客中对于单例模式的分析，所以就想将看后自己的一些收获分享一下。。。