Singleton就是保證一個類只有一個實例，在Ogre里面有很多Singleton的例子，幾乎所有的Manager都是Singleton的實例。比較下Gof里面的Singleton的實現和loki中的Singleton的實現，Ogre的Singleton算是比較簡單的。Gof中實現一般是把類的構造函數給Private了然后再加上static的變量和函數實現的。下面來具體看一下Ogre中的Singleton

先來看一下Singleton的構造函數是Public的，這樣不是大家都能用了？往下看，第一句就是assert(!ms_Singleton); 如果ms_Singleton不是0的話，也就是Singleton<T>已經有了一個自己的對象，那么程序就死翹翹了。如果是0，那么跳過13-16行，直接看17行的
ms_Singleton = static_cast<T*>(this),有沒有注意到那個this，出現在這里有點詭異。這里是構造函數，對象的初始化還沒有完成呢，那么this指向的東西是什么呢？先來看一下怎么生成一個Singleton的實例。

上面是一個超簡單的實現，主要來看一下a = new Intsin(3);這里系統先按照Intsin的大小分配一塊內存出來，然后調用Intsin的構造函數，當然要先運行基類Singleton<Intsin>的構造函數，這時Singleton構造函數的this指針應該是指向剛才分配的那個Intsin對象的地址了，雖然里面的東西不完整，但是this指向的對象的基本框架已經有了。所以可以這樣使用它。要想知道這時this指針指向的對象到底有什么東西，什么東西沒有，可以搜索一下“構造函數的this”看一下有關文章。當構造函數完成的時候，new返回一個指針。這樣就完成了一個實例了。
下面來說一下，這個類什么東西沒做，用的時候要注意什么。
1.當要實例化一個已經被實例化的類時，會有assert(!ms_Singleton);所以一定不能這樣做。
2.對一個實例的指針兩次調用delete也是讓程序崩潰的好辦法
3.Singleton<>不負責對象的解析，所以一定要記得自己delete，記住就一次。
總結下，這里的Singleton的實現比較簡單，也很好用，但是程序員要負責的東西比較多。在Ogre中幾乎所有的Singleton對象都是在root里面new和delete的。
就這么多吧。

看一下Ogre里面的ShagedPtr,其實就是一個Smart Pointers。下面的代碼是刪去了原有注釋的。現不談里面的MUTEX。

#ifndef __SharedPtr_H__
#define __SharedPtr_H__
#include "OgrePrerequisites.h"
namespace Ogre {
    template<class T> class SharedPtr {
    protected:
        T* pRep;           
        unsigned int* pUseCount; //看到這里，應該能知道，SharedPtr是通過引用計數來管理pRep的壽命      
    public:
        OGRE_AUTO_SHARED_MUTEX            
        SharedPtr() : pRep(0), pUseCount(0)
        {
            OGRE_SET_AUTO_SHARED_MUTEX_NULL
        }／／允許有一個空的SharedPtr,不指向任何的對象。

        template< class Y>
        explicit SharedPtr(Y* rep) : pRep(rep), pUseCount(new unsigned int(1))
        {
            OGRE_SET_AUTO_SHARED_MUTEX_NULL
            OGRE_NEW_AUTO_SHARED_MUTEX
        }//這個寫法是Member Templates，很有用，這樣就允許用一個Y對象的指針來初始化一個SharedPtr<T>
                 //下面還能看到很多這樣的Member Templates
                 //要是以前沒見過的人，推薦看一下C++ Templates的第5章、第3節
                 //try this:   vector<int> intvec;
                 //       vector<float> floatvec;
                 //       floatvec = intvec ???????
                 //提一下，所有的初始化函數都沒有檢查rep是否非空，所以SharedPtr接受一個Null指針
                 //安全檢查在每次調用的時候
                 //這里還使用了關鍵字explicit，禁止了隱式轉換

        SharedPtr(const SharedPtr& r)
            : pRep(0), pUseCount(0)
        {
            OGRE_SET_AUTO_SHARED_MUTEX_NULL
            OGRE_MUTEX_CONDITIONAL(r.OGRE_AUTO_MUTEX_NAME)
            {
                OGRE_LOCK_MUTEX(*r.OGRE_AUTO_MUTEX_NAME)
                OGRE_COPY_AUTO_SHARED_MUTEX(r.OGRE_AUTO_MUTEX_NAME)
                pRep = r.pRep; //注意下與后面的不同
                pUseCount = r.pUseCount;
                // Handle zero pointer gracefully to manage STL containers
                if(pUseCount)
                {
                    ++(*pUseCount); 
                }
            }
        }

        SharedPtr& operator=(const SharedPtr& r) {
            if (pRep == r.pRep)
                return *this;
            SharedPtr<T> tmp(r);
            swap(tmp);
            return *this;
        }//這里的寫法有點意思，本來在pRep指向r.pRep之前對pRep做一次release，
                 //但是這里沒看到，其實是通過tmp這個局部變量的自動解析實現的。
        template< class Y>
        SharedPtr(const SharedPtr<Y>& r)
            : pRep(0), pUseCount(0)
        {
            OGRE_SET_AUTO_SHARED_MUTEX_NULL
            OGRE_MUTEX_CONDITIONAL(r.OGRE_AUTO_MUTEX_NAME)
            {
                OGRE_LOCK_MUTEX(*r.OGRE_AUTO_MUTEX_NAME)
                OGRE_COPY_AUTO_SHARED_MUTEX(r.OGRE_AUTO_MUTEX_NAME)
                pRep = r.getPointer(); //這里用的是函數，和上面那個的區別？？
                pUseCount = r.useCountPointer();
                // Handle zero pointer gracefully to manage STL containers
                if(pUseCount)
                {
                    ++(*pUseCount);
                }
            }
        }
        template< class Y>
        SharedPtr& operator=(const SharedPtr<Y>& r) {
            if (pRep == r.pRep)
                return *this;
            SharedPtr<T> tmp(r);
            swap(tmp);
            return *this;
        }
        virtual ~SharedPtr() {
            release();
        }
        inline T& operator*() const { assert(pRep); return *pRep; }
        inline T* operator->() const { assert(pRep); return pRep; }
                //在用的時候檢查pRep的合法性
        inline T* get() const { return pRep; }
        void bind(T* rep) {
            assert(!pRep && !pUseCount);
            OGRE_NEW_AUTO_SHARED_MUTEX
            OGRE_LOCK_AUTO_SHARED_MUTEX
            pUseCount = new unsigned int(1);
            pRep = rep;
        }
        inline bool unique() const { OGRE_LOCK_AUTO_SHARED_MUTEX assert(pUseCount); return *pUseCount == 1; }
        inline unsigned int useCount() const { OGRE_LOCK_AUTO_SHARED_MUTEX assert(pUseCount); return *pUseCount; }
        inline unsigned int* useCountPointer() const { return pUseCount; }
        inline T* getPointer() const { return pRep; }
        inline bool isNull(void) const { return pRep == 0; }
        inline void setNull(void) {
            if (pRep)
            {
                // can't scope lock mutex before release incase deleted
                release();
                pRep = 0;
                pUseCount = 0;
            }
        }

    protected:

        inline void release(void)
        {
            bool destroyThis = false;
            OGRE_MUTEX_CONDITIONAL(OGRE_AUTO_MUTEX_NAME)
            {
                OGRE_LOCK_AUTO_SHARED_MUTEX
                if (pUseCount)
                {
                    if (--(*pUseCount) == 0)
                    {
                        destroyThis = true;
                    }
                }
            }
            if (destroyThis)
                destroy();

            OGRE_SET_AUTO_SHARED_MUTEX_NULL
        }

        virtual void destroy(void)
        {
            delete pRep;
            delete pUseCount;
            OGRE_DELETE_AUTO_SHARED_MUTEX
        }

        virtual void swap(SharedPtr<T> &other)
        {
            std::swap(pRep, other.pRep);
            std::swap(pUseCount, other.pUseCount);
#if OGRE_THREAD_SUPPORT
            std::swap(OGRE_AUTO_MUTEX_NAME, other.OGRE_AUTO_MUTEX_NAME);
#endif
        }
    };

    template<class T, class U> inline bool operator==(SharedPtr<T> const& a, SharedPtr<U> const& b)
    {
        return a.get() == b.get();
    }

    template<class T, class U> inline bool operator!=(SharedPtr<T> const& a, SharedPtr<U> const& b)
    {
        return a.get() != b.get();
    }
}
#endif
最后有注意到：
    inline T* get() const { return pRep; }
    inline T* getPointer() const { return pRep; }
不知道為啥要這樣，有一個不就行了么。
更多的細節、使用方法放到下次把。