#include<iostream>
#include<memory>
using namespace std;

// my implementation of unique_ptr, without specialization for T[]

template<typename T>
struct Box {
private:
  T* ptr{nullptr};
  Box(T* n) : ptr{n} {}  // private constructor
public:
  Box() {}
  ~Box() { if (ptr) delete ptr; }
  T& operator *() { return *ptr; }
  T* operator ->() { return ptr; }
  operator bool() { return ptr != nullptr; }  // if (box1) ..

  // move semantics
  template<typename Up>
  Box(Box<Up>&& other) {
    ptr = static_cast<T*>(other.ptr);
    other.ptr = nullptr;
  }

  template<typename Up>  
  Box<T>& operator =(Box<Up>&& other) {
    if (this == (Box<T>*)&other) return *this;
    if (ptr) delete ptr;
    ptr = static_cast<T*>(other.ptr);
    other.ptr = nullptr;
    return *this;
  }

  // delete copy semantics manually
  Box(const Box<T>& other) = delete;
  const Box<T>& operator =(const Box<T>& other) = delete;

  template<typename... Args>
  static Box<T> New(Args&&... args) noexcept {
    return Box<T>(new T(forward<Args>(args)...));
  }

  template<typename TY, typename... Args>  
  friend Box<TY> make_box(Args&&... args) noexcept;

  template<typename Up>
  friend struct Box;
};

template<typename T, typename... Args>  
Box<T> make_box(Args&&... args) noexcept {
  return Box<T>(new T(forward<Args>(args)...));
}

struct A {
  //Box<int> n{make_box<int>(1)};
  unique_ptr<int> n{make_unique<int>(1)};
  virtual int f() = 0;
  virtual ~A() {} //= default;
};
struct B:A {
  //Box<int> m{make_box<int>(2)};
  unique_ptr<int> m{make_unique<int>(2)};
  // default destructor overrides virtual destructor.
  int f() override { return 1; }
};
struct B2:B {
  unique_ptr<int> z{make_unique<int>(3)};
  // default destructor overrides virtual destructor.
  int f() override { return 1; }  
};
struct C:A {
  int f() override { return 2; }
};

struct D {
  Box<int> n;
};

void willitleak() {
  //Box<A> b = Box<B>::New();
  Box<B> b2 = Box<B2>::New();
}

int testbox() {
  Box<int> a = Box<int>::New(4);
  Box<int> b = Box<int>::New(5);
  //a = b; //move(b);
  a = move(b);
  Box<int> c = make_box<int>(6);
  cout << *a << endl;
  cout << *c << endl;
  
  Box<A> n = Box<B>::New();
  Box<C> m = Box<C>::New();
  //n = m;
  n = move(m);

  D d1;
  D d2 = move(d1);
  while (1) willitleak();
  return 0;
}


////////////////////////// shared_ptr and weak_ptr //////////////////

template<typename T>
struct Rc {           // "reference counter"
private:
  T* ptr{nullptr};
  unsigned int* refcount{nullptr};
  int* weakcount{nullptr};  // make sure weak pointers properly handled
  Rc(T* n) : ptr{n} {
    refcount = new unsigned int(1);
    weakcount = new int(0);
  }
  void deallocate() {
    (*refcount)--;
    if (*refcount==0) {
      delete ptr;
      delete refcount;
      if (*weakcount == 0) delete weakcount;
      else *weakcount = -1 * *weakcount;  // indicates weak ptrs now invalid
    }
  }
public:
  Rc() {}
  ~Rc() {
    if (refcount) deallocate(); 
  }
  void drop() {
    if (refcount) {
      deallocate();
      refcount = nullptr;
      ptr = nullptr;
      weakcount = nullptr;
    }
  }
  
  T& operator *() { return *ptr; }
  T* operator ->() { return ptr; }

  template<typename Up>
  Rc(Rc<Up>& other) {
    ptr = static_cast<T*>(other.ptr);
    refcount = other.refcount;
    weakcount = other.weakcount;
    if (refcount) (*refcount)++;
  }

  template<typename Up>
  Rc<T>& operator =(Rc<Up>& other) {
    if (this == (Rc<T>*)&other) return other;
    if (refcount) deallocate();
    ptr = static_cast<T*>(other.ptr);
    refcount = other.refcount;
    weakcount = other.weakcount;
    if (refcount) (*refcount)++;
    return other;
  }

  template<typename Up>  
  Rc(Rc<Up>&& other) {
    ptr = static_cast<T*>(other.ptr);
    refcount = other.refcount;
    weakcount = other.weakcount;
    other.ptr = nullptr;
    other.refcount = nullptr;
    other.weakcount = nullptr;
  }

  template<typename Up>    
  void operator =(Rc<Up>&& other) {
    if (this == (Rc<T>*)&other) return;
    if (refcount) deallocate();
    ptr = static_cast<T*>(other.ptr);
    refcount = other.refcount;
    weakcount = other.weakcount;
    other.ptr = nullptr;
    other.refcount = nullptr;
    other.weakcount = nullptr;
  }

  unsigned int use_count() {
    if (refcount) return *refcount;
    else return 0;
  }

  template<typename... Args>
  static Rc<T> New(Args&&... args) {
    return Rc<T>(new T(forward<Args>(args)...));
  }

  template<typename U>
  friend struct Weak;

  template<typename Up>
  friend struct Rc;
};  // Rc

template<typename T>
struct Weak {
private:
  T* ptr{nullptr};
  unsigned int* refcount{nullptr};
  int* weakcount{nullptr};

  void deallocate() {
    if (weakcount) {
      if (*weakcount>0) (*weakcount)--;
      else if (*weakcount < -1) (*weakcount)++;
      else delete weakcount;
    }
  }
public:
  Weak() {}
  ~Weak() { deallocate(); }
  void drop() { deallocate(); weakcount=nullptr; }
  
  Weak(Rc<T>& other) {
    if (!other.weakcount || *other.weakcount<0) throw "Assignment of Weak pointer to invalidated Rc";
    ptr = other.ptr;
    refcount = other.refcount;
    weakcount = other.weakcount;
    (*weakcount)++;
  }

  void operator =(Rc<T>& other) {
    if (!other.weakcount || *other.weakcount<0) throw "Assignment of Weak pointer to invalidated Rc";
    deallocate();
    ptr = other.ptr;
    refcount = other.refcount;
    weakcount = other.weakcount;
    (*weakcount)++;
  }

  Weak(const Weak<T>& other) {
    if (!other.weakcount || *other.weakcount<0) throw "Assignment of Weak pointer to invalidated Weak pointer";
    ptr = other.ptr;
    refcount = other.refcount;
    weakcount = other.weakcount;
    (*weakcount)++;
  }

  const Weak<T>& operator =(const Weak<T>& other) {
    if (this == &other) return other;
    if (!other.weakcount || *other.weakcount<0) throw "Assignment of Weak pointer to invalidated Weak pointer";
    deallocate();
    ptr = other.ptr;
    refcount = other.refcount;
    weakcount = other.weakcount;
    (*weakcount)++;
    return other;
  }

  Rc<T> lock() {
    if (weakcount && *weakcount>0) {
      Rc<T> rc;
      rc.ptr = ptr;
      rc.refcount = refcount;
      rc.weakcount = weakcount;
      (*refcount)++;
      return rc;
    }
    else throw "lock on invalidated Rc";
  }

  int weak_count() { if (weakcount) return *weakcount; else return 0; }
};

void doesitleak() {
  Rc<int> a = Rc<int>::New(3);
  Weak<int> w1 = a;
  Weak<int> w2 = a;
  Rc<int> b = move(a);
  //b.drop();
  //cout << w2.weak_count() << endl;
  //w2.drop();
  //cout << w1.weak_count() << endl;
  //w1.drop();
  //*w1.lock() = 5;
  //cout << *w2.lock() << endl;

  Weak<int> w3 = w2;
  Rc<A> n;
  n = Rc<B>::New();
}

int main() {
  doesitleak();
  //while (true) doesitleak();
  return 0;
}