C++设计模式之单例模式Singleton 模式与全局变量区别

很多情况下， 我们使用 Singleton 模式达到的效果和全局变量达到的效果类似。但是， 全局变量不能防止实例化多个对象。Singleton 模式的意图“保证一个类仅有一个对象，并提供一个访问它的全局访问点”，因此全局变量可以达到后面半句的效果， 但是却不能保证仅有一个对象被实例化。另外， 使用全局变量将使得对象在无论是否用到都要被创建，而 Singleton 模式则没有这个瑕疵。

Singleton 的子类化问题。一般来说 Singleton 的子类并不是 Singleton，因此在保证Singleton 的正确子类化，在实现上要注意以下几点（ C++实现）：

① 父类 Singleton 的构造函数为 Protected，目的是为了要让 Singleton 子类访问，而不让 Client 程序访问（防止被其他方式实例化类）； Singleton 子类构造函数声明为 private或者 protected，并且将父类 Singleton 声明为子类 Singleton 的友元， 目的是在父类Singleton 中可以实例化子类 Singleton，而 Client 程序不可访问（防止被其他方式实例化类）。

② 我们必须改写父类 Singleton 中的 Instance 方法（获得唯一实例方法）。 因为 Instance是 static 的成员函数， 不能以多态的方式实现之。 因此我们必须在父类 Singleton 中就是提供真正实例化 Singleton 子类的信息。 我们可以通过到某一个专门的地方获取 Singleton子类的信息，例如提供一个获取函数，在 Instance 实例化 Singleton 子类之前获得这个信息，再根据这个信息去实例化具体的 Singleton 子类。我这里提供的示例程序中是，提供一个全局的 GetSingletionTyp（）， 返回应该实例化的 Singleton 具体子类。 具体的实现则是是通过随机数来确定的方式，详细请参看代码。以下就将整个代码给出：

Singleton.h

#ifndef _SINGLETON_H_
#define _SINGLETON_H_
#include <iostream>

using namespace std;

class Singleton
{
public:
    static Singleton* Instance();
    virtual void PrintInfo();

protected:
    Singleton();
private:
    static Singleton* _instance;
};

class SingletonDeriveA:public Singleton
{
private:
    friend class Singleton;
    SingletonDeriveA();
public:
    virtual ~SingletonDeriveA();
    void PrintInfo();
};

class SingletonDeriveB:public Singleton
{
private:
    friend class Singleton;
    SingletonDeriveB();
public:
    virtual ~SingletonDeriveB();
    void PrintInfo();
};

char* GetSingletionType();
#endif //~_SINGLETON_H_

Singleton.cpp

#include "Singleton.h"
#include <ctime> //for time
#include <iostream>

using namespace std;

Singleton* Singleton::_instance = 0;

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

Singleton* Singleton::Instance()
{
    const char* type = GetSingletionType();
    if (_instance == 0)
    {
        if (strcmp(type,"SingletonDeriveA") == 0)
        {
              _instance = new SingletonDeriveA();
        }
        else if (strcmp(type,"SingletonDeriveB") == 0)
        {
             _instance = new SingletonDeriveB();
        }
        else
        {
             _instance = new Singleton();
        }
    }
    return _instance;
}

void Singleton::PrintInfo()
{
    cout<<"Singleton type:Singleton"<<endl;
}

SingletonDeriveA::SingletonDeriveA()
{
    cout<<"SingletonDeriveA...."<<endl;
}

SingletonDeriveA::~SingletonDeriveA()
{
}

void SingletonDeriveA::PrintInfo()
{
    cout<<"Singleton type:SingletonDeriveA"<<endl;
}

SingletonDeriveB::SingletonDeriveB()
{
    cout<<"SingletonDeriveB...."<<endl;
}

SingletonDeriveB::~SingletonDeriveB()
{
}

void SingletonDeriveB::PrintInfo()
{
    cout<<"Singleton type:SingletonDeriveB"<<endl;
}

char* GetSingletionType()
{
    //随机返回一个 Singleton 子类
    srand((unsigned int)time(NULL));
    int SINGLETON_TYPE = rand() % 3;
    switch (SINGLETON_TYPE)
    {
        case 0:
             return "SingletonDeriveA";
             break;
        case 1:
             return "SingletonDeriveB";
             break;
        case 2:
             return "Singleton";
             break;
        default :
             return "Singleton";
             break;
    }
}

main.cpp

#include "Singleton.h"
#include <iostream>
using namespace std;

int main(int argc,char* argv[])
{
    for (int i = 0; i < 10; ++i)
    {
        Singleton* sgn = Singleton::Instance();
        sgn->PrintInfo();
    }
    //Singleton* sgn1 = new SingletonDeriveA(); //compile error，保证不能通过其他方式实例化类
    return 0;
}

测试程序运行的结果是， 虽然我们请求了 10 次 Singleton 对象， 但是只实例化了一次（从调用构造函数的次数就可以知道）。比较遗憾也是要说明的是：由于 GetSingletionType（）实现策略不是很好， 运行后 10 次返回的随机数取模后的结果是一样的， 因此获得 Singleton对象是一样的，但是不同时刻运行的结果可以不一样。