单例模式

 1 　　/**
 2     * @class Singleton
 3     * @brief This is a  class for managing singleton \n
 4     * objects allocated on the heap.
 5     */
 6     class Singleton
 7     {
 8     public:
 9     
10         /**
11          * Create a static object
12          * @return Singleton
13          */
14         static Singleton * Instance()
15         {
16             if(NULL == m_pInstance)  
17                 m_pInstance = new Singleton();
18     
19             return m_pInstance;
20         }
21     
22         /**
23          * Destroy Singleton object
24          */
25         static void Unistance()
26         {
27             if(0 == m_pInstance)
28             {
29                 delete m_pInstance;
30                 m_pInstance = 0;
31             }
32         }
33     
34     private:
35         Singleton() : m_pInstance(0) {} 
36         Singleton(const Singleton&);
37         Singleton& operator=(const Singleton&);
38     
39         static Singleton *m_pInstance;
40     };
41 
42 
43     /**
44     * @class Singleton
45     * @brief This is a template class for managing singleton objects allocated 
46     * on the heap.
47     * For example 
48     * class Test : public Singleton<Test>
49     * {
50     *        friend class Singleton<Test>;
51     * }
52     */
53     template <class T>
54     class Singleton
55     {
56     public:
57         /**
58          * Create a static object
59          * @return T*
60          */
61         static T* Instance()
62         {
63             if ( 0 == s_instance )
64             {
65                 s_instance = new T;
66             }
67     
68             return s_instance;
69         }
70     
71         /**
72          * Destroy Singleton object
73          */
74         static void Uninstance()
75         {
76             if ( 0 != s_instance )
77             {
78                 delete s_instance;
79                 s_instance = 0;
80             }
81         }
82     
83     protected:
84         Singleton() {}
85         virtual ~Singleton() {}
86     
87     private:
88         Singleton(const Singleton<T> &);
89         Singleton<T>& operator= (const Singleton<T> &);
90     
91         static T* s_instance;
92     };
93     
94     template <class T>
95     T* Singleton<T>::s_instance = 0;