Singleton单例模式

singleton单例模式

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



解析：

Singleton模式其实是对全局静态变量的一个取代策略，singleton模式的两个作用在C++中是通过如下的机制实现的：

1）仅有一个实例，提供一个类的静态成员变量，大家知道类的静态成员变量对应类的所有对象而言是唯一的

2）提供一个访问他的全局访问点，也就是提供对应的访问这个静态成员变量的静态成员函数，对类的所有对象而言也是唯一的。

在C++中，可以直接使用类域进行访问而不必初始化一个类的对象。

小demo

singleton.h

[cpp] view plain copy

#ifndef SINGLETON_H

#define SINGLETON_H

/*

下面的实现其实是singleton的一个简单实现，并不是特别通用，一般的，如果一个项目中需要使用到singleton模式比较多的话，那么一般会实现一个singleton的模板类，模板类的模板参数是需要采用singleton模式的类，比如这样实现
http://blog.csdn.net/ouyangshima/article/details/7651708
template<typename T>

class Singleton

{

//...。类的声明

};

//需要采用singleton模式的类

class Test : pulic Singleton<Test>

{

//...。类的声明

};

*/

#include <iostream>

class Singleton

{

public:

// 静态成员函数,提供全局访问的接口

static Singleton* GetInstancePtr();

static Singleton GetInstance();

void Test();

private:

Singleton(){};

~Singleton(){};

static Singleton* m_pStatic;// 静态成员变量,提供全局惟一的一个实例

class Garbo //它的唯一的工作就是在析构函数中删除Singleton的实例

{

public:

~Garbo()

{

if (Singleton::m_pStatic)

{

delete Singleton::m_pStatic;

}

}

};//内嵌一个私有类，以防该类被在其他地方滥用

static Garbo mGarbo;//定义一个静态成员，在程序结束的时候，系统会调用它的析构函数

};

#endif

singleton.cpp

[cpp] view plain copy

#include "Singleton.h"

#include <iostream>

// 类的静态成员变量要在类体内进行声明,需要在cpp文件进行定义赋值，若在.h文件中赋值，当多个文件都保护.h文件时会出现重定义。

Singleton* Singleton::m_pStatic = NULL;//定义并初始化

Singleton* Singleton::GetInstancePtr()

{

if (NULL == m_pStatic)

{

m_pStatic = new Singleton();

}

return m_pStatic;

}

Singleton Singleton::GetInstance()

{

return *GetInstancePtr();

}

void Singleton::Test()

{

std::cout << "Test!\n";

}

main.cpp

[cpp] view plain copy

#include "Singleton.h"

#include <stdlib.h>

#include <iostream>

using namespace std;

int main()

{

//Singleton* s2=&(Singleton::GetInstance());//无法访问private或protected成员

// 不用初始化类对象就可以访问了

Singleton* s1=Singleton::GetInstancePtr();

s1->Test();

Singleton* s2=Singleton::GetInstancePtr();

if (s1==s2)

std::cout<<"ok"<<std::endl;

else

std::cout<<"no"<<std::endl;

system("pause");

return 0;

}

Sinleton模式经常和Factory（AbstractFactory）模式在一起使用，因为系统中工厂对象一般来说只要一个，这里的工厂对象实现就是同时是一个Singleton模式的实例，因为系统我们就只要一个工厂来创建对象就可以了。