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

template<typename T>
struct Box;
template<typename T, typename... Args>
Box<T> make_box(Args&&... x);

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

  /*
  Box(Box<T>&& other) {  // move constructor
    ptr = other.ptr;
    other.ptr = nullptr;
  }
  */

  T* release() {
    T* temp = ptr;
    ptr = nullptr;
    return temp;
  }

  template<typename Up>   // required to recognize derived classes
  Box(Box<Up>&& b) {
    ptr = static_cast<T*>(b.release());
  } // move constructor

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

  // explicitly delete copy semantics
  Box(const Box<T>& b) = delete;
  Box<T>& operator =(const Box<T>& b) = delete;

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

  template<typename TY, typename... Args>
  friend Box<TY> make_box(Args&&... x);
};

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

struct A {
  virtual int f() = 0;
};

struct B : A {
  int f() override { return 1; }
};

struct C : A {
  int f() override { return 2; }
};

struct D {
  Box<int> b;
  //unique_ptr<int> b;
};

int main() {
  Box<int> a = Box<int>::New(4);
  Box<int> b = Box<int>::New(6);
  *b = 9;
  a = move(b);
  cout << *a << endl;

  unique_ptr<A> au = make_unique<B>();
  Box<int> c =make_box<int>(8);
  Box<A> s = Box<B>::New();
  Box<A> t = make_box<B>();
  s = move(t);
  s = Box<C>::New();
  //Box<B> s2 = Box<C>::New();
  Box<A> S[] = {Box<B>::New(), Box<C>::New()};
  for(auto& b:S) cout << b->f() << endl;

  D d1;
  D d2;
  d1 = move(d2);
  return 0;
}