C++单例模式实现

C++单例模式的实现方法多样化，应用比较灵活，大家可以根据自己编程中不同的需求来决定使用哪种方法来实现这一功能。

 

C++是一款应用非常广泛的计算机编程语言。它支持多种程序设计风格，其中包括对面向对象设计的支持。今天为大家介绍的C++单例模式也称为单件模式、单子模式。使用单例模式，保证一个类仅有一个实例，并提供一个访问它的全局访问点，该实例被所有程序模块共享。有很多地方需要这样的功能模块，如系统的日志输出等。

C++单例模式有许多种实现方法，在C++中，甚至可以直接用一个全局变量做到这一点，但这样的代码显得很不优雅。《设计模式》一书中给出了一种很不错的实现，定义一个单例类，使用类的私有静态指针变量指向类的唯一实例，并用一个公有静态方法获取该实例。如下面的类定义：

 

class CSingleton
{
        // 其它成员
public:
        static CSingleton * GetInstance()
        {
                if (m_pInstance == NULL)
                        m_pInstance = new CSingleton();
                return m_pInstance;
        }
private:
        CSingleton(){};
        static CSingleton * m_pInstance;
} 

单例类CSingleton有以下特征：

 

◆它有一个指唯一实例的静态指针m_pInstance，并且是私有的。

◆它有一个公有的函数，可以获取这个唯一的实例，并在需要的时候创建该实例。

◆它的构造函数是私有的，这样就不能从别处创建该类的实例。

大多时候，这样的实现都不会出现问题。有经验的读者可能会问，m_pInstance指向的空间什么时候释放呢？更严重的问题是，这个实例的析构操作什么时候执行？ 如果在类的析构行为中有必须的操作，比如关闭文件，释放外部资源，那么上面所示的代码无法实现这个要求。我们需要一种方法，正常地删除该实例。

可以在程序结束时调用GetInstance并对返回的指针调用delete操作。这样做可以实现功能，但是不仅很丑陋，而且容易出错。因为这样的附加代码很容易被忘记，而且也很难保证在delete之后，没有代码再调用GetInstance函数。

一个妥善的方法是让这个类自己知道在合适的时候把自己删除。或者说把删除自己的操作挂在系统中的某个合适的点上，使其在恰当的时候自动被执行。

我们知道，程序在结束的时候，系统会自动析构所有的全局变量。事实上，系统也会析构所有的类的静态成员变量，就像这些静态成员也是全局变量一样。利用这个特征，我们可以在C++单例模式类中定义一个这样的静态成员变量，而它的唯一工作就是在析构函数中删除单例类的实例。如下面的代码中的CGarbo类（Garbo意为垃圾工人）：

 

class CSingleton
{
// 其它成员
public:
        static CSingleton * GetInstance(){。。。}
private:
        CSingleton(){};
        static CSingleton * m_pInstance;
        class CGarbo // 它的唯一工作就是在析构函数中删除CSingleton的实例
        {
        public:
                ~CGarbo()
                {
                        if (CSingleton::m_pInstance)
                                delete CSingleton::m_pInstance;
                }
        };
static CGarbo Garbo; // 定义一个静态成员，在程序结束时，系统会调用它的析构函数
} 

类CGarbo被定义为CSingleton的私有内嵌类，以防该类被在其它地方滥用。

在程序运行结束时，系统会调用CSingleton的静态成员Garbo的析构函数，该析构函数会删除单例的唯一实例。

使用这种方法释放单例对象有以下特征：

◆在单例类内部定义专有的嵌套类。

◆在单例类内定义私有的专门用于释放的静态成员。

◆利用程序在结束时析构全局变量的特性，选择最终的释放时机。

◆使用C++单例模式的代码不需要任何操作，不必关心对象的释放。

 

在下面的对象图中，有一个"单例对象"，而"客户甲"、"客户乙" 和"客户丙"是单例对象的三个客户对象。可以看到，所有的客户对象共享一个单例对象。而且从单例对象到自身的连接线可以看出，单例对象持有对自己的引用。

一些资源管理器常常设计成单例模式。让一个类产生同一个对象对客户端服务的时候，比如管理数据库连接,管理文件IO等，这时我们就要使用到单例模式。下面是该模式的C++实现(注泽说明)

#include <iostream>   
using namespace std;   
//单例类的C++实现   
class Singleton   
{   
private:   
Singleton();//注意:构造方法私有   
virtual ~Singleton();   
static Singleton* instance;//惟一实例   
int var;//成员变量(用于测试)   
public:   
static Singleton* GetInstance();//工厂方法(用来获得实例)   
int getVar();//获得var的值   
void setVar(int);//设置var的值   
};   

//构造方法实现   
Singleton::Singleton()   
{   
this->var = 20;   
cout<<"Singleton Constructor"<<endl;   
}   
Singleton::~Singleton()   
{   
     delete instance;   
}   
//初始化静态成员   
Singleton* Singleton::instance=new Singleton();   
Singleton* Singleton::GetInstance()   
{   
return instance;   
}   
//seter && getter含数   
int Singleton::getVar()   
{   
return this->var;   
}   
void Singleton::setVar(int var)   
{   
this->var = var;   
}   
//main   
int main(int argc, char* argv[])   
{   
Singleton *ton1 = Singleton::GetInstance();   
Singleton *ton2 = Singleton::GetInstance();   
cout<<"ton1 var = "<<ton1->getVar()<<endl;   
ton1->setVar(150);
cout<<"ton2 var = "<<ton2->getVar()<<endl;

return 0;   
}

输出如下:

Singleton Constructor
   ton1 var = 20
   ton2 var = 150

在输出结果中，构造方法只调用了一次，ton1与ton2是指向同一个对象的。

在这个例子中存在问题，就是该实例的内存回收问题，下次完善。