设计模式之单例模式

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

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;

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