#include <iostream>
#include <memory>

using namespace std;

/*
 * Implementing shared_ptr using unique_ptr!
 */
template <typename T>
class smart_ptr {

	/*
	 * First we need an auxiliary class to hold the pointer
	 * and a count of references to it.
	 */
    template <typename Tprime>
    class smart_ptr_aux {
        unique_ptr<Tprime> ap;
        int count = 1;
      public:
        smart_ptr_aux(Tprime *p)
            : ap(p) {}

	T *get() const {return ap.get();}

	/*
	 * The functions increment and decrement adjust the count,
	 * deleting the object pointed to and this auxiliary object when
	 * the count falls to zero. The decrement function must be static
	 * in order to delete the object p. The increment function is made
	 * static for consistency.
	 */
        static void decrement(smart_ptr_aux<Tprime> *aux) {
            aux->count--;
            cerr << "dec:Used " << aux->count << " times\n";
            if (aux->count == 0) {
                delete aux;
                cerr << "dec:Deleted managed object\n";
            }
        }
        static void increment(smart_ptr_aux<Tprime> *aux) {
            aux->count++;
            cerr << "inc:Used " << aux->count << " times\n";
        }

    };
	/*
	 * Now the smart pointer class itself uses the inc/dec methods in
	 * its constructors, destructors, and assignment operator.
	 */

    smart_ptr_aux<T> *field;
  public:

    smart_ptr( T *p )
        : field(new smart_ptr_aux<T>(p)) {}

    ~smart_ptr() {
        smart_ptr_aux<T>::decrement(field);
    }
    smart_ptr(const smart_ptr<T> & p) : field(p.field) {
        smart_ptr_aux<T>::increment(field);
    }
    smart_ptr& operator=(const smart_ptr<T> & other) {
        if (&other != this) {
            smart_ptr_aux<T>::decrement(field);
            field = other.field;
            smart_ptr_aux<T>::increment(field);
        }
        return *this;
    }

    T &operator*() { return *(field->get()); }

    T *operator->() const { return field->get(); }

};

int main() {
    int *ip = new int(13);

    smart_ptr<int> sp1(ip);
    {
        auto sp2(sp1);

        cerr << "sp2:Value is " << *sp2 << endl;
    }
    cerr << "sp1:Value is " << *sp1 << endl;

    return 0;
}