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