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;
}
};