#ifndef PTR_H
#define PTR_H
#include <stdexcept>

template<class T> class Ptr{
 public:
  Ptr(T * pek = 0) throw(std::bad_alloc);
  Ptr(const Ptr& other) throw();
  ~Ptr() throw();
  const Ptr& operator=(const Ptr& other);
  T& operator*();
  const T& operator*() const;
  T* operator->();
  const T* operator->() const;
  bool operator==(const Ptr& other) const;
  bool operator!=(const Ptr& other) const;
  operator T*() const throw();
  template<class OT>
    operator Ptr<OT>();
 private:
  T * pointer;
  int * count;
  template<class U> friend class Ptr;
  Ptr(T *p, int *c);
};

template<class T> Ptr<T>::Ptr(T *pek) throw(std::bad_alloc):
  pointer(pek), count((pointer)?new int(1):0){}

template<class T> Ptr<T>::Ptr(const Ptr<T>& other) throw():
  pointer(other.pointer), count(other.count){
  if (pointer)
    (*count)++;
}

template<class T> Ptr<T>::Ptr(T *p, int *c): pointer(p), count(c){
  if (pointer)
    (*count)++;
}

template<class T> Ptr<T>::~Ptr() throw(){
  if (pointer && --*count == 0){
    delete count;
    delete pointer;
  }
}

template<class T> const Ptr<T>& Ptr<T>::operator=(const Ptr<T>& other){
  if (pointer != other.pointer){
    if (pointer && --*count == 0){
      delete count;
      delete pointer;
    }
    pointer = other.pointer;
    count = other.count;
    if (pointer)
      ++*count;
  }
  return * this;
}

template<class T>  T& Ptr<T>::operator*(){
  return *pointer;
}

template<class T>  const T& Ptr<T>::operator*() const{
  return *pointer;
}

template<class T> T* Ptr<T>::operator->(){
  return pointer;
}

template<class T> const T* Ptr<T>::operator->() const{
  return pointer;
}

template<class T> bool Ptr<T>::operator==(const Ptr<T>& other) const{
  return pointer == other.pointer;
}

template<class T> bool Ptr<T>::operator!=(const Ptr<T>& other) const{
  return pointer != other.pointer;
}

template<class U> template<class OT> Ptr<U>::operator Ptr<OT>(){
  return Ptr<OT>(pointer, count);
}

template<class T> Ptr<T>::operator T*() const throw(){
  return pointer;
}

#endif