C++设计模式之Singleton模式

一、功能

　　保证一个类仅有一个实例。 

二、结构图

三、优缺点

　　Singleton模式是做为"全局变量"的替代品出现的。所以它具有全局变量的特点：全局可见、贯穿应用程序的整个生命期，它也具有全局变量不具备的性质：同类型的对象实例只可能有一个。

四、实现

  
  

   
   class Singleton
  
  
  
  

   
   {
public:
    static Singleton* Instance();

protected:
    Singleton() { }

private:
    static Singleton* _instance;
    Singleton(const Singleton&);
    Singleton& operator=(const Singleton&);
};

Singleton* Singleton::_instance = NULL;

Singleton* Singleton::Instance()
{
    (_instance == NULL) ? _instance = new Singleton() : 0; //lazy initialization
    return  _instance;
  
  
}

(1)因为返回的是指针，为防止用户调用delete函数，可把static Singleton *_instance；改为在Instance()中定义static Singleton _instance。这样显然更安全，同时也具有lazy initialization的特性(即第一次访问时才创建)。 

(2)假设需要从Singleton派生子类，而子类也需要有同样的性质，既只能创建一个实例。我觉得，这很难办。根本原因在于Instance()函数不是虚函数，不具有多态的性质。一种常用方法是把Instance()函数移到子类中，这时就只能用static Singleton *_instance，而不能用static Singleton _instance了，除非把_instance也要移到子类，无论怎么做都不优雅。另一种方法是用模板。具体用什么方法，只能根据实际情况权衡。

五、示例代码

　(1)没子类的情况

  
  

   
   namespace DesignPattern_Singleton
{
    class Singleton
    {
    public:
        static Singleton* Instance() { static Singleton _instance; return &_instance; }
    protected:
        Singleton() { }
    private:
        Singleton(const Singleton&);
        Singleton& operator=(const Singleton&);
    };
}
//客户端代码：
{
    using namespace DesignPattern_Singleton ;
    Singleton *p = Singleton::Instance() ;
    ......
}
  
  

 

　(2)有子类的情况 

方法一：

  
  

   
   namespace DesignPattern_Singleton
{
    // class Singleton
    class Singleton {
    protected:
        Singleton() { }
        static Singleton *_instance;
    private:
        Singleton(const Singleton&);
        Singleton& operator=(const Singleton&);
    };

    Singleton* Singleton::_instance = NULL;

    // class ConcreteSingleton
    class ConcreteSingleton : public Singleton {
    public:
        static Singleton* Instance() ;
    protected:
        ConcreteSingleton() {}
    };

    Singleton* ConcreteSingleton::Instance()
    {
        (_instance == NULL) ? _instance = new ConcreteSingleton() : 0; 
        return _instance;
    }
}
//客户端代码：
{
    using namespace DesignPattern_Singleton ;
    Singleton *p = ConcreteSingleton::Instance() ;
}
  
  

 

方法二：

  
  

   
   namespace DesignPattern_Singleton
{
    // class Singleton
    class Singleton {
    protected:
        Singleton() { }
    private:
        Singleton(const Singleton&);
        Singleton& operator=(const Singleton&);
    };

    // class ConcreteSingleton
    class ConcreteSingleton : public Singleton {
    public:
        static Singleton* Instance() { static ConcreteSingleton _instance; return &_instance; }
    protected:
        ConcreteSingleton() { }
    };
}
//客户端代码：
{
    using namespace DesignPattern_Singleton ;
    Singleton *p = ConcreteSingleton::Instance() ;
}
  
  

 

方法三：

  
  

   
   namespace DesignPattern_Singleton
{
    template <class T>
    class Singleton {
    public:
        static T* Instance() { static T _instance; return &_instance; }
    protected:
        Singleton() { }
    private:
        Singleton(const Singleton &);
        Singleton& operator=(const Singleton&);
    };

    class ConcreteSingleton : public Singleton<ConcreteSingleton> { } ;
}
//客户端代码
{
    using namespace DesignPattern_Singleton ;
    ConcreteSingleton *p = ConcreteSingleton::Instance() ;
}