Singleton模式,类模板,多线程

Singleton模式据说是面试的时候考的最多的一种设计模式，所以这两天认真研究了一下Singleton模式，中间也遇到了一些问题，还好最终都慢慢得以解决

Singleton模式也是单例模式，目的主要是实例化唯一一个对象，有且只有一个，我们当然不可以通过构造函数直接实例化，这样的话对象将不止一个了，所以我们将构造函数声明为private或者protected,同样的道理拷贝构造函数、赋值操作函数也声明为private,既然不可以通过构造函数，那只能通过类直接调用成员函数进而来实例化对象，通过类直接调类调用类成员，这就用到了static，将类直接调用的成员函数声明为static ,返回值为实例化对象。为了保证实例化对象的唯一型，我们每次进行一个判断，判断的成员变量为静态成员变量static。

说了这么多，不如直接贴出来代码： //CSingleton.h #ifndef _CSINGLETON_H_ #define _CSINGLETON_H_ #include <stdio h=""> class Lock { private: //CCriticalSection _cs; }; class CSingleton { public: static CSingleton* NewInstance(); ~CSingleton(); protected: private: CSingleton(); CSingleton(const CSingleton& cs);//防止通过拷贝构造函数实例对象 CSingleton& operator = (const CSingleton& cs);//防止通过复制构造函数实例对象 private: static CSingleton* _sig; </stdio>#include "stdafx.h" #include <stdlib h=""> #include "CSingleton.h" #include <iostream> using namespace std; CSingleton* CSingleton::_sig = NULL; CSingleton::CSingleton() { cout<<"this is Singleton......"<<endl; } CSingleton::~CSingleton() { } CSingleton* CSingleton::NewInstance() { if(NULL == _sig) { _sig = new CSingleton(); } return _sig; } </iostream></stdlib>

关于delete实例化的对象，我们可以使用atexit()，具体的代码待会就给贴出来。

如过有很多个类都是只要实例化一个对象，那我们就可以将这个类写成类模板至于多线程，我们需要在实例化之前加锁。大概就是这样，

下面贴出来代码，已经在VS2012下测试通过：

//synobj.h #ifndef _SYNOBJ_H_ #define _SYNOBJ_H_ #include <windows h=""> //#define CLASS_UNCOPYABLE(classname)\ // private:\ // classname(const classname&);\ // classname& operator = (const classname&); class Mutex { //CLASS_UNCOPYABLE(Mutex); public: Mutex(); ~Mutex(); void lock(); void unlock(); protected: private: CRITICAL_SECTION _cs; }; class Lock { //CLASS_UNCOPYABLE(Lock); public: explicit Lock(Mutex& cs); ~Lock(); private: Mutex& _cs; }; #endif </windows>

//synobj.cpp #include "stdafx.h" #include "synobj.h" Mutex::Mutex():_cs() { InitializeCriticalSection(&_cs); } Mutex::~Mutex() { DeleteCriticalSection(&_cs);; } void Mutex::lock() { EnterCriticalSection(&_cs); } void Mutex::unlock() { LeaveCriticalSection(&_cs); } Lock::Lock(Mutex& cs):_cs(cs) { _cs.lock(); } Lock::~Lock() { _cs.unlock(); } //singleton.h #ifndef _SINGLETON_H_ #define _SINGLETON_H_ #include "synobj.h" #include <stdlib h=""> template<typename t=""> class Singleton { public: static T* Instance() { if(NULL == _instance) { Lock lock(_mutex); if(NULL == _instance) { T* temp = new T; _instance = temp; //_instance = new T(); atexit(Destory); } } return _instance; } protected: Singleton(){} ~Singleton(){} private: Singleton(Singleton& ); Singleton& operator = (Singleton& ); static void Destory() { if(NULL != _instance) { delete _instance; _instance = NULL; } } private: static T* _instance; static Mutex _mutex; }; template<typename t=""> T* Singleton<t>::_instance = NULL; template<typename t=""> Mutex Singleton<t>::_mutex; </t></typename></t></typename></typename></stdlib> // Singleton21.cpp : 定义控制台应用程序的入口点。 // #include "stdafx.h" #include "singleton.h" #include "synobj.h" #include <stdio h=""> #include <iostream> using namespace std; class A:public Singleton<a> { friend Singleton<a>; public: void DoSomething() { cout<<"hello DoSomething"<<endl private:="" a="" a="" int="" _tmain="" int="" argc="" _tchar="" argv="" a="" a="A::Instance();" a-="">DoSomething(); A* b =A::Instance(); b->DoSomething(); //A* c = new A(); //c->DoSomething(); if(a == b) { cout<<"Singleton Success"<<endl; } else { cout<<"Singleton Fail"<<endl; } getchar(); return 0; } </endl></a></a></iostream></stdio>为什么要把类模板中的构造函数声明为protected?程序员在使用模板类时最常犯的错误是将模板类视为某种数据类型。所谓类型参量化(parameterized types)这样的术语导致了这种误解。模板当然不是数据类型，模板就是模板，恰如其名：编译器使用模板，通过更换模板参数来创建数据类型。这个过程就是模板实例化(Instantiation)。从模板类创建得到的类型称之为特例(specialization)。因为classA:public template {},这里要用到继承，所以我们类模板中的构造函数不能私有，必须声明为public或者protected在类A中，我们为了维护类A实例的唯一型，所以我们要将其构造函数声明为protected或者private,这样的话在模板类中Instance中的T* temp = new T;这一句将报错，为什么呢？因为类A中构造函数为protected，我们可以在类A中将template声明为friend，即friend singleton ，这样问题就解决了.参考URL：http://blog.csdn.net/look01/article/details/3228134