单例模式的c++实现

#pragma once

#include <iostream>
#include <memory>
#include <Windows.h>
using namespace std;
/***************************************************************************************

1、首先要有一个创建实例的静态函数GetInstance
2、实现的方式既可以通过new动态创建，也可以通过static静态局部变量实现
3、创建的时机既可以通过静态变量初始化时创建，也可以在调用GetInstance函数时再创建,通过静态变量的初始化的好处是
它是在进入主函数之前创建成功的可以避免多线程的问题，但是坏处就是在程序启动时初始化会拖慢启动过程。
4、为了防止通过调用构造函数创建实例，要将类的构造、复制构造和赋值构造函数设为私有的
5、GetInstance函数的返回值既可以是指针，又可以是引用，当是指针的时候要防止它在中途被delete掉，因此要将析构函数设为私有的
6、这种模式有点像全局变量，但还是有区别的，单件的作用是保证只有一份实例，而能够全局访问是它附带的功能。

********************************************************//////////////////////////////////////
class singleton1
{
public:
    static singleton1* GetInstance()
    {
        if(ptr == NULL)
            ptr = new singleton1;
        return ptr;
    }

    static void show()
    {
        cout << "singleton1::show" << endl;
    }

private:
    ~singleton1()
    {
        cout << "dest singleton1" << endl;
    }
    static singleton1* ptr;
    singleton1()
    {
        cout << "cstr singleton1" << endl;
    }

    singleton1(const singleton1 &);
    singleton1& operator=(const singleton1 &);
};

singleton1* singleton1::ptr = new singleton1;

/*****************
1、在上面的实现中，使用指针时，不能销毁实例，只有当程序结束时才由系统回收，考虑将指针设计成智能指针shared_ptr，
但是智能指针的回收还是要调用析构函数，声明为public，指针随时会被delete，有很多问题，所以这种方法是不太实用
*****************/
class singleton3
{
public:
    ~singleton3()
    {
        cout << "dest singleton3" << endl;
    }

    static singleton3* GetInstance()
    {
        if(ptr.get() == NULL)
            ptr.reset(new singleton3);
        return ptr.get();
    }

    static void show()
    {
        cout << "singleton3::show" << endl;
    }

private:
    static shared_ptr<singleton3> ptr;
    singleton3(){}
    singleton3(const singleton3 &);
    singleton3& operator=(const singleton3 &);
};

shared_ptr<singleton3> singleton3::ptr;

/****************************************
1、上面的实现都是基于new动态创建，并且返回的都是指针类型，这个实现基于静态局部变量，并且返回引用类型
2、返回引用而不是指针的好处是，不用担心中间会被delete掉
3、采用静态局部变量的好处是，内存管理交给系统，不需要手动管理
****************************************/
class singleton4
{
public:
    ~singleton4()
    {
        cout << "dest singleton4" << endl;
    }

    static singleton4& GetInstance()
    {
        static singleton4 s;
        return s;
    }

    static void show()
    {
        cout << "singleton4::show" << endl;
    }

private:
    singleton4(){;}
    singleton4(const singleton4 &);
    singleton4& operator=(const singleton4 &);
};

/***************************
1、如果是在GetInstance函数中创建实例，并且是多线程的话，如果有多个线程同时调用该函数，
则可能会创建多个实例，所以要对创建过程进行加锁处理
**************************/
CRITICAL_SECTION g_cs;
class Lock
{
public:
    Lock()
    {
        InitializeCriticalSection(&g_cs);
    }

    void LockOn()
    {
        EnterCriticalSection(&g_cs);
    }

    void LockOff()
    {
        LeaveCriticalSection(&g_cs);
    }

    ~Lock()
    {
        DeleteCriticalSection(&g_cs);
    }
};
Lock g_lock;

class singleton5
{
public:
    ~singleton5()
    {
        cout << "dest singleton5" << endl;
    }

    static singleton5* GetInstance()
    {
        if(ptr == NULL)
        {
            //采用双重判断是为了提高效率，防止每次都要执行加锁过程
            g_lock.LockOn();
            if(ptr == NULL)
                ptr = new singleton5;
            g_lock.LockOff();
        }

        return ptr;
    }

    static void show()
    {
        cout << "singleton5::show" << endl;
    }

private:
    static singleton5* ptr;
    singleton5(){}
    singleton5(const singleton5 &);
    singleton5& operator=(const singleton5 &);
};
singleton5* singleton5::ptr = NULL;

/******************
1、上面的实现虽然满足了多线程调用，但是实际中可能会有很多类都要设计成实例模式，
那么就需要都按照上面那样实现一遍，不能重用，下面的模板类就可以满足重用的需求
*******************************/
template <typename T>
class Singleton
{
public:
    static T& Instance()
    {
        if (m_pInstance == NULL)
        {
            //Lock lock;
            g_lock.LockOn();
            if (m_pInstance == NULL)
            {
                m_pInstance = new T;
                atexit(&Destroy);//将Destroy注册为程序结束时的执行函数释放内存
            }

            //return *m_pInstance;
            g_lock.LockOff();
        }

        return *m_pInstance;
    }

protected:
    Singleton(void) 
    {
        cout << "cstr Singleton" << endl;
    }
    virtual ~Singleton(void) 
    {
        cout << "dest Singleton" << endl;
    }

private:
    Singleton(const Singleton& rhs)
    {
        cout << "copy cstr Singleton" << endl;
    }
    Singleton& operator = (const Singleton& rhs) 
    {
        cout << "= cstr Singleton" << endl;
    }

    static void Destroy()
    {
        if (m_pInstance != NULL)
            delete m_pInstance;
        m_pInstance = NULL;
    }

    static T* m_pInstance;
};

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

//实际的单例类就按照下面的方式实现
class SingletonInstance : public Singleton<SingletonInstance>
{
public:
    friend Singleton<SingletonInstance>;
    void show()
    {
        cout << "SingletonInstance::show" << endl;
    }
//
private:
    SingletonInstance() 
    {
        cout << "cstr SingletonInstance" << endl;
    }
    virtual ~SingletonInstance(void) 
    {
        cout << "dest SingletonInstance" << endl;
    }

    SingletonInstance(const SingletonInstance& rhs) 
    {
        cout << "copy cstr SingletonInstance" << endl;
    }
};

//测试类
class SingletonTest
{
public:
    SingletonTest()
    {
        //singleton1& s1 = singleton1::GetInstance1();
        //s1.show();

        //singleton1 *p1 = singleton1::GetInstance();
        //p1->show();
        ////delete p1;

        //singleton3 *p3 = singleton3::GetInstance();
        //p3->show();

        //singleton4 &p4 = singleton4::GetInstance();
        //p4.show();

        //singleton5 *p5 = singleton5::GetInstance();
        //p5->show();

        SingletonInstance &si = SingletonInstance::Instance();
        si.show();
    }
};