单例模式是保证一个类只有一个实例,并提供一个访问它的全局访问点,该实例被所有程序模块共享。
本文提供两种方式实现单例模板类: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是唯一的访问路径,由于构造函数是私有的,无法通过构造函数创建实例,同样也无法使用复制构造函数和赋值运算符,这样保证了在任一时候该类只有一个实例。
多线程情况下单例模式的修改及使用,后续补充说明…