第62课 单例类模板 密码保护

1. 单例需求的提出

（1）在架构设计时，某些类在整个系统生命期中最多只能有一个对象存在(Single Instance)

（2）问题：如何定义一个类，使得这个类最多只能创建一个对象

2. 单例模式

（1）要控制类的对象数目，必须对外隐藏构造函数

（2）思路

　　①将构造函数的访问属性设置为private

　　②定义instance，并初始化为NULL

　　③提供静态函数getInstance来返回单例实例，并判断当instance的值为空时，并创建对象，并保存在instance指针中，非空值时直接返回instance标记的对象。

【编程实验】单例模式初探

#include <iostream>
#include <string>

using namespace std;

class SObject
{
    //静态c_instance，用于保存实例对象的指针
    static SObject* c_instance;
    
    //隐藏构造函数，拷贝构造、赋值操作符
    SObject(const SObject&);
    SObject& operator=(const SObject&);
    SObject(){}
public:
    static SObject* GetInstance();
    void print()
    {
        cout << "this = " << this << endl;
    }
};

SObject* SObject::c_instance = NULL;
SObject* SObject::GetInstance()
{
    if( c_instance == NULL)
    {
        c_instance = new SObject();
    }
    
    return c_instance;
}

int main()
{
    SObject* s = SObject::GetInstance();
    SObject* s1 = SObject::GetInstance();
    SObject* s2 = SObject::GetInstance();

    s->print();   //打印出来的3个对象地址值一样，说明是单例
    s1->print();
    s2->print();
      
    return 0;
}

3. 单例类的设计

（1）存在问题

　　必须为每个单例类定义c_instance静态成员变量和GetInstance()静态成员函数。而这些不是类本身的职责，而且每个类都这样定义这两者也是个重复的劳动过程。

（2）解决方案

　　将单例模式相关的代码抽取出来，开发单例类模板。当需要单例类时，直接使用单例类模板

【编程实验】单例类模板

//Singleton.h

#ifndef _SINGLETON_H_
#define _SINGLETON_H_

template <typename T>
class Singleton
{
    static T* c_instance;    
public:
    static T* GetInstance();
};

template <typename T>
T* Singleton<T>::c_instance = NULL;

template <typename T>
T* Singleton<T>::GetInstance()
{
    if(c_instance == NULL)
    {
        c_instance = new T();
    }
    
    return c_instance;
}

#endif

//test.cpp

#include <iostream>
#include "Singleton.h"

using namespace std;

class SObject
{
    //当前类需要使用单例模式
    //可以先忽略下一行代码，直接去看main中的函数，然后再回来理解
    //这里为什么要将Singleton<SObject>类声明为SObject类的友元类？
    //其目的是为了让Singleton<SObject>类内部可以调用SObject的己被
    //私有的构造函数
    friend class Singleton<SObject>;
    
    //要单例的类，须将构造函数、拷贝构造函数和赋值操作符隐藏起来
    //否则外界可以随便new
    SObject(const SObject&);
    SObject& operator=(const SObject&);
    SObject(){}
    
public:
    void print()
    {
        cout << "this = " << this << endl;
    }
};

int main()
{
    //Singleton<SObject>虽然是通过类模板产生的，但其实是一个实实在在
    //存在的新的类，然后通过这个类，去创建SObject类的一个实例，由于
    //Singleton<SObject>类内部的GetInstance控制了SObject对象的实例
    //的产生。因此，每个调用getInstance就只能获得SObject的一个对象。
    //本质上，单例类模板是通过模板去创建一个类，然后利用这个类来控制另一个
    //类对象的创建！

    SObject* s = Singleton<SObject>::GetInstance();
    SObject* s1 = Singleton<SObject>::GetInstance();
    SObject* s2 = Singleton<SObject>::GetInstance();

    s->print();   //打印出来的3个对象地址值一样，说明是单例
    s1->print();
    s2->print();
      
    return 0;
}

【编程实验】boost库中的单例类模板

//Singleton.h

#ifndef _SINGLETON_H_
#define _SINGLETON_H_

//boost库的单例类模板（饿汉式，多线程安全的单例模板类）
template <typename T>
struct singleton_default
{
private:
    singleton_default(); //模板类的构造函数私有化
    //内部类
    struct object_creator
    {
         object_creator(){singleton_default<T>::instance();}
         inline void do_nothing()const{}
    };
    
    static object_creator create_object; //声明：内部类的静态实例
public:
    typedef T object_type;
    static object_type& instance()
    {
        static object_type obj; //要单例的类实例，放在静态区里
        
        //空函数，据说这与模板类的编译有关，可以确保内部类运行
        //该函数时，其构造函数(调用了{singleton_default<T>::instance())
        //被执行
        create_object.do_nothing();
        
        return obj;
    }
};

template<typename T>
typename singleton_default<T>::object_creator   //typename==class，内部类类型
singleton_default<T>::create_object;    //定义内部类的静态实例

#define INSTANCE(class_name) singleton_default<class_name>::instance();
                                        
#endif  //_SINGLETON_H_

//test.cpp

#include<iostream>
#include "Singleton.h"

using namespace std;

class Test
{
private:
    //构造函数私有化
    Test(){}
    Test(const Test&);
    Test& operator=(const Test&);
    
    friend class singleton_default<Test>;

public:
    void print()
    {
        cout << "test::this " << this <<endl;
    }
};

int main()
{
    Test& t= INSTANCE(Test);
    t.print();
    
    Test& t2=INSTANCE(Test);
    t2.print();
    return 0;
};

4. 小结

（1）单例模式是开发中最常用的设计模式之一

（2）单例模式的应用使得一个类最多只有一个对象

（3）可以将单例模式的相关的代码抽象成类模板

（4）需要使用单例模式的类直接使用单例类模板