设计模式之单件

设计模式中，单件又被称之为单例模式，

1、意图

保证一个类仅有一个实例，并提供一个访问的它的全局访问点

2、适用的场景

    类仅仅有一个实例，而且客户可以从一个众所周知的访问点访问它

    当这个唯一的实例应该支持通过子类化进行扩展，并且用户应该无需更改代码就能使用一个扩展的实例，（实例里面应该是需要修改的）

 

实现

 

常见的使用模式有三种：

1、保证一个唯一的实例

class Singleton{
public:
      static Singleton *Instance();  //静态成员函数来定义这个类操作
protected:
     Singleton();
private:
static Singleton * _instance;        //包含了一个指向它的唯一的指针
};

Singleton* Singleton::_ instance = 0;

Singleton* Singleton::Instance()
{
   if(instance  == 0){
       _instance   = new Singleton();
    }
    return _instance;
}

Singleton::Singleton()
{
  cout<<"construct"<<endl;
}

需要注意的是，构造函数为保护型的，这就保证了仅仅只有一个实例可以被构造。

2、创建Singleton类的子类

class Singleton{
public:
      static void register(const char *name, Singleton *);
      static Singleton *Instance();  
protected:
     static Singleton* Lookup(const char *name);
     Singleton();
private:
      static Singleton * _instance;        //包含了一个指向它的唯一的指针
      static List<NameSingletonPair> * _registry;
};

Singleton* Singleton::_ instance = 0;

Singleton* Singleton::Instance()
{
   if(instance  == 0){
        const char *singletonName = getenv("SINGLETON");
         //
         _instance = Lookup(singletonName );
    }
    return _instance;
}

子类注册：在自己的构造函数中进行注册
MySingleton::MySingleton()
{
    Singleton::Register("MySingleton", this);
}

Singleton 类不再负责创建单件，它的主要职责是使供选择的单件对象在系统中可以被访问。潜在的缺点：Singleton子类的实例就必须被创建，否则他们不会被注册，说的就是注册的过程在构造函数中。

3、   第三种例子

class MazFactory{
public:
    static MazFactory* Instance();
protected:
    MazFactory();
private:
     static  MazFactory* _instance;
};

MazFactory *MazFactory::_instance = 0;


//普通的实现
MazFactory* MazFactory ::Instance()
{
    if(_instance == 0){
        _instance = new MazFactory(); 
   }
    
    return _instance;
} 

//有多个子类的时候

MazFactory* MazFactory ::Instance()
{
    if(_instance == 0){
        const char *mazeStyle = getenv("MAZESTYLE");
        
         if(strcmp(mazeStyle, "bombed") == 0){
               _instance = new BombedMazFactory(); 
         }else if(strcmp(mazeStyle, "bombed") == 0) 
         {
               _instance = new EnchantedMazFactory(); 
          }
           .........//其他的子类
    }else{
      _instance = new MazFactory; 
    }
    
    return _instance;
} 

这样一个不好的地方，就是每定义一个MazFactory的子类， instance都必须被修改，这是一个不好的地方。

 

突然想起的一个原则，单例设计模式涉及到的就是一个类只专注于做一件事。