#include<iostream>
using namespace std;

// my own version of shared_ptr;

template<typename T>
struct Weak;


template<typename T>
class Rc {
private:
  T* ptr{nullptr};
  int* refcount{nullptr};
  Rc(T* p) {
    ptr = p;
    refcount = new int(1);
  }

  void dealloc() {
    if ((*refcount) < 1) {
      delete ptr;
      delete refcount;
      ptr = nullptr;
      refcount = nullptr;
    }
  }
public:
  Rc() {}
  ~Rc() {
    if (refcount) {
      (*refcount)--;
      dealloc();
    }
  }// destructor

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

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

  // copy semantics
  Rc(const Rc<T>& other) {
    ptr = other.ptr;
    refcount = other.refcount;
    if (refcount) (*refcount)++;
  }

  const Rc<T>& operator =(const Rc<T>& other) {
    if (refcount && ptr!=other.ptr) {
      (*refcount)--;
      dealloc();
    }
    if (ptr!=other.ptr && other.refcount) (*other.refcount)++;
    ptr = other.ptr;
    refcount = other.refcount;
    return other;
  }

  // move semantics
  Rc(Rc<T>&& other) {
    ptr = other.ptr;
    refcount = other.refcount;
    other.refcount = nullptr;
    other.ptr = nullptr;
  }

  void operator =(Rc<T>&& other) {
    if (refcount && ptr != other.ptr) {
      (*refcount)--;
      dealloc();
    }
    ptr = other.ptr;
    refcount = other.refcount;
    other.refcount = nullptr;
    other.ptr = nullptr;
  }

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

  friend struct Weak<T>;
};

// also need weak.

template<typename T>
struct Weak {
private:
  T* ptr{nullptr};
  int* refcount{nullptr};
public:
  Weak() {}
  Weak(const Rc<T>& other) {
    ptr = other.ptr;
    refcount = other.refcount;
  }
  void operator =(const Rc<T>& other) {
    ptr = other.ptr;  
    refcount = other.refcount;
  }
  Rc<T> lock() {
    Rc<T> temprc;
    temprc.ptr = ptr;
    temprc.refcount = refcount;
    if (refcount) (*refcount)++;
    return temprc;
  }
  bool expired() {
    if (!ptr || !refcount) return true;
    else return (*refcount)<1;
  }
  int use_count() {
    if (!ptr || !refcount) return 0;
    else return *refcount;
  }
};
// flaw: Rc* refed could get deallocated, leaving a dangling raw pointer.

struct bad_share {
  int A[10];
  Rc<bad_share> other;
};

void leaktest() {
  auto a = Rc<bad_share>::New();
  auto b = Rc<bad_share>::New();
  a->other = b;
  b->other = a;
}

struct fixed_share {
  int A[10];
  Weak<fixed_share> other;
};

void noleaktest() {
  auto a = Rc<fixed_share>::New();
  auto b = Rc<fixed_share>::New();
  a->other = b;
  b->other = a;
}


void test() {
  Rc<int> a = Rc<int>::New(4);
  Rc<int> b = Rc<int>::New(5);
  a = b;
  Rc<int> c = Rc<int>::New(6);
  c = move(b);

  Weak<int> w = a;
  Rc<int> locked = w.lock();
  
  cout << a.use_count() << endl;
  cout << b.use_count() << endl;
  cout << c.use_count() << endl;  
}

int main() {
  //while (1) test();
  test();
  while (1) noleaktest();
  return 0;
}