2. Singleton模式

这两种方法都提到了使用模版：

（1） 参考文章：http://www.cnblogs.com/08shiyan/archive/2012/03/16/2399617.html

不同：   

   a. 该方法直接使用auto_ptr来释放指针所指资源； 但auto_ptr在C++11中被 unique_ptr 替代了；

   b.将 Singleton类的构造和析构函数设为private型， 然后使用 friend 函数（宏定义，这里我给替换回来了）来访问这两个函数， 以构造和析构对象。

// Singleton.h  模版类
template <class T>
    class Singleton
    {
    public:
        static inline T* getInstance()
        {
         　if(pInstance.get() == 0)

      　　  {
           　　 pInstance.reset(new T);
        　　}
       　　 return pInstance.get();
        }

private:
        Singleton(void){};
        ~Singleton(void){};
        Singleton(const Singleton&){};
        Singleton& operator=(const Singleton&){};
        static auto_ptr<T> pInstance; // 静态成员变量
    };

    template<class T>
    auto_ptr<T> Singleton<T>::pInstance;// 静态成员变量初始化，需在class声明之外
//----------------------------------------------
// ServiceManager.h  使用模版 定义一个Singleton 模式的类
#include "Singleton.h"
#include <iostream>
using namespace Pattern;
class ServiceManager
{
public:
    void Run()
    {
        std::cout<< "ServiceManger run!~~" << std::endl;
    }
private:
    ServiceManager(){}
    ~ServiceManager(){}

    ServiceManager(const ServiceManager& s){};
    ServiceManager& operator=(const ServiceManager& s){};

    friend class auto_ptr<ServiceManager>; // 采用友元方式，使得可访问ServiceManager 类的 private的构造函数和析构函数， 使得该类ServiceManager成为Singleton模式
    friend class Singleton<ServiceManager>;

};//--------------------------------------------------------------
// Test.cpp

#include "ServiceManager.h"
int main(int argc, char* argv[])
{
    Singleton<ServiceManager>::getInstance()->Run();
    system("pause");
    return 0;
}

 

（2） 参考文章： http://www.cnblogs.com/hujian/archive/2010/12/15/1906503.html

不同：  

  a. 该方法在一个static的结构体的析构函数中释放指针所指资源； （有点麻烦，不如auto_ptr 简便）

  b. 将 Singleton类的构造和析构函数设为protected型， 然后使用继承的方式来访问这两个函数， 以构造和析构对象。

#include <iostream>

template<typename T>
class Singleton2
{
private:
    static T* pInstance; // 静态成员变量
    typedef struct Singleton2_Term  // 定义一个对象用于析构
    {
        ~Singleton2_Term()
        {
           if (getInstance() != NULL)
           {
               delete getInstance();
               getInstance() = NULL;
           }
        }
    };
protected: // 可被子类访问
    Singleton2(){}
    ~Singleton2(){}
    Singleton2(const Singleton2& singleton){}
    Singleton2& operator= (const Singleton2& singleton){}
public:
    static T* &getInstance() // 加 & , 可以做左值
    {
        static Singleton2_Term term;
        if (pInstance == NULL)
        {
            pInstance = new T();
        }
        return pInstance;
    }
};

template<typename T>
T *Singleton2<T>::pInstance = NULL; //静态成员变量初始化， 在类声明之外
//------------------------------------------------
// ServiceManager2.h 
#pragma once
#include "Singleton2.h"
class ServiceManager2 : public Singleton2<ServiceManager2> // 采用继承的方式
{
   
public:
    void Run()
    {
        std::cout<< "ServiceManager2 run!~~" << std::endl;
    }
private:
    ServiceManager2(void){};
    ~ServiceManager2(void){};
    ServiceManager2(const ServiceManager2& s){};
    ServiceManager2& operator=(const ServiceManager2& s){};

   friend class Singleton2<ServiceManager2>; // 定义友元

}; //------------------------------------------------------- 

// Test.cpp 
#include "ServiceManager2.h"

 int main(int argc, char* argv[]) 
{ 
   ServiceManager2::getInstance()->Run();
   system("pause"); 

   return 0;  
}