C++单例模板类

单例模式是保证一个类只有一个实例，并提供一个访问它的全局访问点，该实例被所有程序模块共享。

本文提供两种方式实现单例模板类：1、使用私有静态指针变量 2、使用局部静态变量， 具体如下：

1、私有静态指针变量

struct Uncloneable
{
protected:
	Uncloneable() {}
	~Uncloneable(){}
private:
	Uncloneable(const Uncloneable& rhs);
	Uncloneable& operator=(const Uncloneable& rhs);
};

//懒汉模式
template<typename T>
struct SingleTon_One : private Uncloneable{
	static T& instance()
	{
		if (NULL == point)
		{
			point = new T;
		}
		return *point;
	}

private:
	//唯一作用在析构函数中删除SingleTon_One的实例
	struct CGarbo {
		~CGarbo()
		{
			if (NULL != SingleTon_One::point)
			{
				delete SingleTon_One::point;
				SingleTon_One::point = NULL;
			}
		}
	};
protected:
	SingleTon_One() {}		//构造函数为protected，继承它的子类可以调用其构造函数
private:
	static T* point;
	static CGarbo cbo;
};

template<typename T>
T* SingleTon_One<T>::point = NULL;

/*   用于测试的子类 1 */
struct Object : SingleTon_One<Object>
{
	friend SingleTon_One<Object>;		//友元类，确保SingleTon_One可调用子类构造函数
	void setShape(int _length, int _width);
	void dump();
private:
	Object() {}		//每一个子类都要写一个私有构造函数

private:
	int length;
	int width;
};

2、局部静态变量

template<typename T>
struct SingleTon_Two {
	static T& instance()
	{
		static T _instance;
		return _instance;
	}
protected:
	SingleTon_Two() {}
private:
	SingleTon_Two(const SingleTon_Two<T>& rhs);
	SingleTon_Two& operator=(const SingleTon_Two<T>& rhs);
};

/*   用于测试的子类2  */
struct Object_Two : SingleTon_Two<Object_Two>
{
	friend SingleTon_Two<Object_Two>;
	void setShape(int _len, int _wid);
	void dump();
private:
	Object_Two() {}

private:
	int length;
	int width;
};

单例模板类的使用如下：

Object::instance().setShape(1, 3);
Object::instance().dump();

Object_Two::instance().setShape(2, 2);
Object_Two::instance().dump();

instance是唯一的访问路径，由于构造函数是私有的，无法通过构造函数创建实例，同样也无法使用复制构造函数和赋值运算符，这样保证了在任一时候该类只有一个实例。

多线程情况下单例模式的修改及使用，后续补充说明…