设计模式之Singleton(单件)模型

设计模式之Singleton(单件)模型

Singleton（单件）模型：一个类只有一个实例。
下面是C++代码的单件模型：
Class Singleton
{ 
   static Singleton s;
    int i; 
   Singleton(int x):i(x){} 
   Singleton& operator=(Singleton&);//赋值操作符 
   Singleton(const Singleton&);//拷贝构造函数，防止被用户调用，声明为私有
public: 
   static Singleton& instance() 
   {return s;}//产生对象的引用 
   int getValue() {return i;} 
   void SetValue(int x)
   {i = x;}
 };

Singleton Singleton::s(47);

int main(){
   Singleton& s= Singleton::instance();
   cout << s.getvalue() <<endl;
   Singleton& s2 = Singleton::instance()'
   s2.setvalue(9);
   cout<<s.getvalue()<<endl;
}
创建单件的关键是防止程序员控制对象的生存期的权利，所以构造函数，拷贝构造函数，赋值操作符都要声明为私有(本例中没有实现，因为赋值操作符和拷贝构造没用到)，并且防止编译器产生任何缺省的构造函数。
要注意的是，这里的对象可以静态创建，也可以知道程序员根据需求显式创建，这个创建的方式又称为lazy initialzation，这个做法只有在创建的对象的代价不大，并且不总是需要它的情况下才有意义。上面的这个方法并没有限制只创建一个对象，支持创建有若干对象的对象池。如果遇到对象池中共享对象的问题，则可以对进出对象池的对象登记的方法解决。
类中的static静态成员都是一个单件，从这个意义上说，编程语言提供了对单件的直接支持，但是如果一个对象依赖于一个对象时，对象的正确初始化就很重要了。下面是对上面的示例代码的改进。
#include <iostream>
using namespace std;

class Singleton{
   int i;
   Singleton(int x):i(x){}
   void operator=(Singleton&);
   Singleton(const Singleton&);
public:
   static Singleton& intstance(){
   static Singleton s(45);
   return s;
  }
   int getValue() {retrun 1;}
   void setValue() {i = x;}
}

int maint()
{
   Singleton& s= Singleton::instance();
   cout<<s.getValue() <<endl;
   Singleton s2=Singletonf::instance();
   s2.setValue(9);
   cout<<s.getValue<<endl;
}
下面是Scott Meyers两个互相依赖的单间模型,由于是Scott Meyers创建，又称Meyers单件。
 Class Singleton1{
    Singleton1(){}
public： 
   static Singleton1& ref
   {
       static Singleton1 single；
       return single； 
   }
}；
 
Class Singleton2{ 
   Singleton1 &s1； 
   Singleton2(Singleton1& s)：s1(s){}
public: 
   static Singleton2& ref()
   { 
      static Singleton2 single(singleton1::ref)); 
      return single; 
   }
    Singleton1& f()
   {return s1;};

int main()
{ 
      Singleton1& s1 = Singleton2：：ref().f();//导致惟一的Singleton2对象创建，Singleton2创建中，Singleton1：：ref（）被调用，导致Singleton1对象创建。
 }

Singleton-ness是单件模型的变体：利用递归模板实现。
#include <iostream>
using namespace std;

template class Singleton
{ 
   Singleton(const Singleton&); 
   Singleton& operator= (const Singleton&); 
 protected: 
   Singleton(){} 
   vitrual ~Singleton()
   {}
public: 
   static T& instance() 
   {
      static T theInstance; 
      return theInstance; 
   }
};
 
//Sample class to be made into a Singleton
Class MyClass:public Singleton
{
   int x;
protected:
    friend class Singleton ;
    MyClass() 
   { x = 0;}
public: 
   void setValue(int n) 
   {x=n;}
int getVlalue()const 
   {return x;}
};

int main()
{ 
   MyClass& m = MyClass::Instance(); 
   cout << m.getValue()<<endl;
   m.setValue(1);
   cout << m.getValue()<<endl;
}
Singleton<MyClass>为友元；Singleton 不依赖MyClass的大小，实际上这只是对模板参数的静态依赖。只有当MyClass::Instance()被第一次调用时，才需要MyClass的大小。 单件模型实际应用的很少。