#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 main() {
  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;
}