单例模式-C++实现

单例模式  保证一个类只有一个实例，并提供一个访问它的全局访问点

所谓只有一个实例 那就让别人不能随便new 只能从类的一个静态方法得到它的实例，构造函数设为私有的即可

class Singleton
{
private:
static Singleton* Instance;
private:
Singleton();
public:

static Singleton* GetInstance();

};

代码实现:

#include "StdAfx.h"
#include "Singleton.h"
Singleton*  Singleton::Instance = NULL;

Singleton::Singleton(void)
{
}
Singleton* Singleton::GetInstance()
{
if(Instance == NULL)
{
Instance = new Singleton();
}
return Instance;
}

貌似很OK，但是其实我们这边的入口点，不是只有一个的

当我们没有拷贝构造函数和赋值函数的时候，编译器会默认生成一个，所以说程序的入扣点除了现在的静态函数外，还有默认的其他函数

那怎么办呢？

好办，直接将这些函数设为私有的，不实现即可，代码如下

class Singleton

{

private:

static Singleton* Instance;

private:

Singleton();

Singleton(const Singleton&);

Singleton& operator=(const Singleton&);

public:

static Singleton* GetInstance();

};

实现代码同上

那现在怎么样，貌似还有问题，我们看GetInstance()的实现

如果有多个线程进行这个函数调用，会发生什么，会出现创建多个实例，并导致内存泄露

怎么办，加锁

锁文件代码如下:

Lock.h

#include<Windows.h>

class Lock

{

public:
Lock(void);
~Lock(void);
void RequireLock();
void ReleaseLock();
private:
CRITICAL_SECTION m_lock;

};

Lock.cpp

#include "StdAfx.h"
#include "Lock.h"
#include<Windows.h>

Lock::Lock(void)
{

InitializeCriticalSection(&m_lock);
}

Lock::~Lock(void)
{
DeleteCriticalSection(&m_lock);
}
void Lock::RequireLock()
{
EnterCriticalSection(&m_lock);
}
void Lock::ReleaseLock()
{
LeaveCriticalSection(&m_lock);
}

那单例类代码如下:

Singleton.h

#pragma once
#include "Lock.h"
class Singleton
{
private:

static Singleton* Instance;
static  Lock* myLock;
private:
  Singleton();

Singleton(const Singleton&);

Singleton& operator=(const Singleton&);

public:

static Singleton* GetInstance();

    
};

Singleton.cpp

#include "StdAfx.h"
#include "Singleton.h"
Singleton*  Singleton::Instance = NULL;
Lock*  Singleton::myLock = new Lock();
Singleton::Singleton(void)
{
}
Singleton* Singleton::GetInstance()
{
myLock->RequireLock();
if(Instance == NULL)
{
Instance = new Singleton();
}
myLock->ReleaseLock();
return Instance;
}
一切似乎无懈可击，可是当考虑到我们的对象时new出来的，我们需要销毁它，怎么办，将析构函数拿出来调用，我想既然有一个全局的入口点，就应该有一个全局的出口点，再定义一个静态函数，用于销毁new出来的对象，并将析构函数设为私有的

可是问题来了，销毁也有new相同的问题，如果不进行同步的法，一个对象会销毁两次，也会有内存泄露，那我们只用再加一把锁即可，可是还有一种情况，当一个线程创建实例的时候，另外一个线程正在销毁它，好吧，这也需要同步，不能我正在创建的时候，你在销毁它，对象肯定是乱的了

所以不管创建和销毁，我们必须要得到两把锁，一把是用于管理对象创建，一把用于管理对象销毁，不管你是创建和销毁对象，你必须保证先得到这两把锁，保证在任一时刻只有一个线程在创建或者销毁

代码如下:

Singleton.h

class Singleton
{
private:
static Singleton* Instance;
static  Lock* myLock;
static Lock* myDeleteLock;
private:
Singleton();
  Singleton(const Singleton&);

Singleton& operator=(const Singleton&);

 ~Singleton();

public:

static Singleton* GetInstance();

static void DestroyInstance();
};

Singleton.cpp

Singleton*  Singleton::Instance = NULL;
Lock*  Singleton::myLock = new Lock();
Lock*  Singleton::myDeleteLock = new Lock();
Singleton::Singleton(void)
{
}
Singleton::~Singleton(void)
{

}
Singleton* Singleton::GetInstance()
{

myLock->RequireLock();

myDeleteLock->RequireLock();

if(Instance == NULL)
{
Instance = new Singleton();
}
myDeleteLock->ReleaseLock();
myLock->ReleaseLock();
return Instance;
}
void Singleton::DestroyInstance()
{
myLock->RequireLock();
myDeleteLock->RequireLock();
if(Instance != NULL)
{
delete Instance;
Instance = NULL;
}
myDeleteLock->ReleaseLock();
myLock->ReleaseLock();
}

欢迎拍砖