设计模式之单例模式

　　单例模式也称为单件模式，可能是所有模式中使用最广泛也是最简单的设计模。其目的是保证仅有一个类实例，
并提供一个访问它的全局访问点，该实例被所有程序模块共享。费话少说，重在意会，翠花上菜了：
　　下面主要提两种常见的设计方法：普通方法与模板方法
　　

　　/**
    * @class Singleton
    * @brief This is a  class for managing singleton 

    * objects allocated on the heap.
    */
    class Singleton
    {
    public:
    
        /**
         * Create a static object
         * @return Singleton
         */
        static Singleton * Instance()
        {
            if(NULL == m_pInstance)  
                m_pInstance = new Singleton();
    
            return m_pInstance;
        }
    
        /**
         * Destroy Singleton object
         */
        static void Unistance()
        {
            if(0 == m_pInstance)
            {
                delete m_pInstance;
                m_pInstance = 0;
            }
        }
    
    private:
        Singleton() : m_pInstance(0) {} 
        Singleton(const Singleton&);
        Singleton& operator=(const Singleton&);
    
        static Singleton *m_pInstance;
    };


    /**
    * @class Singleton
    * @brief This is a template class for managing singleton objects allocated 
    * on the heap.
    * For example 
    * class Test : public Singleton<Test>
    * {
    *        friend class Singleton<Test>;
    * }
    */
    template <class T>
    class Singleton
    {
    public:
        /**
         * Create a static object
         * @return T*
         */
        static T* Instance()
        {
            if ( 0 == s_instance )
            {
                s_instance = new T;
            }
    
            return s_instance;
        }
    
        /**
         * Destroy Singleton object
         */
        static void Uninstance()
        {
            if ( 0 != s_instance )
            {
                delete s_instance;
                s_instance = 0;
            }
        }
    
    protected:
        Singleton() {}
        virtual ~Singleton() {}
    
    private:
        Singleton(const Singleton<T> &);
        Singleton<T>& operator= (const Singleton<T> &);
    
        static T* s_instance;
    };
    
    template <class T>
    T* Singleton<T>::s_instance = 0;

　　单例模式的优点：
　　　　在内存中只有一个对象，节省内存空间
　　　　避免频繁的创建销毁对象，可以提高性能
　　　　避免对共享资源的多重占用
　　　　可以全局访问