template <class T>
class ref_ptr{
private:
T* ptr;
long * ct;
void dispose() {
if(--*ct <= 0) {
delete ct;
delete ptr;
}
}
public:
//从 new 得到指针的构造函数
explicit ref_ptr(T* p)
: ptr(p), ct(new long(1)) { }
explicit ref_ptr(const T& t)
: ptr(new T), ct(new long(1)) {
*ptr = t;
}
//从另一个指针得到数据的构造函数
ref_ptr(const ref_ptr<T>& p) throw()
: ptr(p.ptr), ct(p.ct) { ++*ct; }
//析构函数
~ref_ptr() { dispose(); }
//赋值运算符
ref_ptr<T>& operator=(const ref_ptr<T>& p) throw() {
if(this!=&p)
{
dispose();
ptr = p.ptr;
ct = p.ct;
++*ct;
}
return *this;
}
//赋值,从原生对象
ref_ptr<T>& operator=(const T& t) throw() {
dispose();
ptr = new T;
*ptr = t;
ct = new long;
*ct = 1;
return *this;
}
//复制新对象,建立新拷贝,前缀运算符
const ref_ptr<T>& operator++() throw() {
if(*ct > 1)
{
T* tmp = new T;
long* tct = new long;
*tmp = *ptr;
*tct = 1;
dispose();
ptr = tmp;
ct = tct;
}
return *this;
}
//复制新对象,建立新拷贝,后缀运算符
const ref_ptr<T>& operator++(int) throw() {
return ++(*this);
}
//指针对象运算符,返回对象引用
T& operator*() const throw() {
return *ptr;
}
//返回对象指针
T* operator->() const throw() {
return ptr;
}
//返回对象引用,类型转换
operator T() const throw() {
return *ptr;
}
};
