用c++来实现单例模式

单例模式是使用广泛的一种设计模式，又称为单件模式、单子模式。其意图是保证一个类仅有一个实列，并提供一个访问它的全局访问点，该实例被所有程序模块共享。有很多的地方都需要这样的功能模块，如系统的日志输出，操作系统只能有一个窗口管理器，一台pc连一个键盘等等。

单例模式有许多种实现方法，在C++中，甚至可以直接用一个全局变量做到这一点，但这样的代码显的很不优雅。 使用全局对象能够保证方便地访问实例，但是不能保证只声明一个对象——也就是说除了一个全局实例外，仍然能创建相同类的本地实例

《设计模式》一书中给出了一种很不错的实现，定义一个单例类，使用类的私有静态指针变量指向类的唯一实例，并用一个公有的静态方法获取该实例。

单例模式通过类本身来管理其唯一实例，这种特性提供了解决问题的方法。唯一的实例是类的一个普通对象，但设计这个类时，让它只能创建一个实例并提供对此实例的全局访问。唯一实例类Singleton在静态成员函数中隐藏创建实例的操作。习惯上把这个成员函数叫做Instance()，它的返回值是唯一实例的指针。

具体定义如下：
 

#include 
 
using namespace std;
class only
{  
private:  
    only()   //构造函数是私有的，这样就不能在其它地方创建该实例
	{
	}
    static only *p;  //定义一个唯一指向实例的静态指针，并且是私有的。
    static int b;
public:  
    static only* GetInstance()   //定义一个公有函数，可以获取这个唯一的实例，并且在需要的时候创建该实例。
    { 
        if(p == NULL)  //判断是否第一次调用  
            p = new only;  
        return p;  
    }  
    static void show()
	{
		cout << b << endl;
	}
};  
int only::b=66;     //static定义的数据成员必须在类外初始化，因为它是整个类的一部分，而不是属于某个对象。
only* only::p=NULL;
int main()
{
	only *a1=only::GetInstance();
        cout << a1 << endl;
	a1->show();	
	only *a2=only::GetInstance();
	cout << a2 << endl;
	a2->show();
    return 0;	
}
————————————————
版权声明：本文为CSDN博主「leikun153」的原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/leikun153/article/details/80583009

运行结果截图：

 

从运行截图中，我们确实能看到实例的两个对象的地址都是一样的，也就是说明单例模式的实现是成功的。

注意：

单例类only有以下特征：
它有一个指向唯一实例的静态指针p，并且是私有的；
它有一个公有的函数，可以获取这个唯一的实例，并且在需要的时候创建该实例；
它的构造函数是私有的，这样就不能从别处创建该类的实例。

用户访问唯一实例的方法只有通过GetInstance()函数，如果不通过该函数，任何创建该实例的尝试都将失败，这是应为将类的构造函数定义为私有函数。

GetInstance()函数使用懒惰初始化，即它的返回值是这个函数首次被访问时创建的，这是一种防弹设计，即所有GetInstance()之后的调用都返回相同实例的指针。

eg：only *p1=only::GetInstance();         only *p2=p1->GetInstance();

但是，问题来了，细心的朋友肯定会发现这样的一个问题：p指向的空间什么时候释放？该实例的析构函数又是什么时候执行呢？

如果类的析构函数中要有必要的行为规范，如：关闭文件，释放外部资源，那么上面的代码显然是无法满足要求的。这时候，我们需要使用一种方法，正常的删除实例，并对返回的指针调用delete操作。这样做可以实现功能，但不仅很丑陋，而且容易出错。因为这样的附加代码很容易被忘记，而且也很难保证在delete之后，没有代码再调用GetInstance函数。

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

我们知道，程序在结束的时候，系统会自动析构所有的全局变量。事实上，系统也会析构所有的类的静态成员变量，就像这些静态成员也是全局变量一样。利用这个特征，我们可以在单例类中定义一个这样的静态成员变量，而它的唯一工作就是在析构函数中删除单例类的实例。

如下面的代码中的CGarbo类（Garbo意为垃圾工人）:
 

#include 
using namespace std;
class only
{  
private:  
    only()   //构造函数是私有的  
	{	
	}
    static only *p;  
    static int b;
	
	class cGarbo
	{
		public:
		~cGarbo()
		{
			if( only::p )
			{
				delete only::p;
				cout << "delete only success " << endl;
			}
		}
	};
	static cGarbo Garbo;
	
public:  
    static only* new_inst()  
    { 
        if(p == NULL)  //判断是否第一次调用  
            p = new only;  
        return p;  
    }  
    static void show()
	{
		cout << b << endl;
	}
};  
int only::b=66;
only* only::p=NULL;
only::cGarbo only::Garbo;
int main()
{
	only *a1=only::new_inst();
    cout << a1 << endl;
	a1->show();
	only *a2=only::new_inst();
	cout << a2 << endl;
	a2->show();
    return 0;	
}

 

从运行结果来看，确实达到我们删除实例的要求。

注意：

类CGarbo被定义为only的私有内嵌类，以防该类被在其他地方滥用。
程序运行结束时，系统会调用only的静态成员Garbo的析构函数，该析构函数会删除单例的唯一实例。
使用这种方法释放单例对象有以下特征：
在单例类内部定义专有的嵌套类；
在单例类内定义私有的专门用于释放的静态成员；
利用程序在结束时析构全局变量的特性，选择最终的释放时机；
使用单例的代码不需要任何操作，不必关心对象的释放。
 

以上文章出处：c++实现单例模式

另外，上面代码在单线程的时候工作正常，但是在多线程的情况下就有问题。如果两个线程同时运行到判断p是否为空时，并且p确实没有创建，那么两个线程就会同时创建一个实例。解决办法是加上一个同步锁，为了提高效率，只有没有创建实例的时候才需要加锁创建唯一实例，否则直接返回实例指针。修改代码如下：

#include 
#include 
using namespace std;

mutex mtx;

class only
{
private:
    only(){}    //构造函数私有，这样就不能在其他地方创建该实例
    static only *p;
    static int b;

    class cGarbo
    {
    public:
        ~cGarbo()
        {
            if(only::p)
            {
                delete only::p;
                cout << "delete only success " << endl;
            }
        }
    };
    static cGarbo Garbo;

public:
    static only* NewInstance()  //定义一个共有函数，可以获取这个唯一的实例，并且在需要的时候创建该实例
    {
        if(p == nullptr)
        {
            mtx.lock();
            if(p == nullptr)
                p = new only;
            mtx.unlock();
        }
        return p;
    }

    static void show()
    {
        cout << b << endl;
    }
};

int only::b = 66;
only* only::p = nullptr;
only::cGarbo only::Garbo;

int main()
{
    only *a1 = only::NewInstance();
    cout << a1 << endl;
    a1->show();

    only *a2 = only::NewInstance();
    cout << a2 << endl;
    a2->show();

    return 0;
}