struct counter {
	size_t shared_counter;
	size_t weak_counter;
};


template <typename T>
class shared_ptr {
public:
	shared_ptr() : shared_ptr{nullptr} {};
	shared_ptr(T* ptr);

	shared_ptr(const shared_ptr& obj);

	~shared_ptr();

	T& operator * () { return *obj_;}

private:
	shared_ptr(T* obj, counter* counter_);

	void dealloc();

	T* obj_;
	counter* counter_;

	template <typename U>
	friend class weak_ptr;
};

template <typename T>
class weak_ptr {
public:
	weak_ptr(const shared_ptr<T>& ptr);
	weak_ptr(const weak_ptr& ptr);

	~weak_ptr();

	shared_ptr<T> shared();
private:
	T* obj_;
	counter* counter_;
};



template <typename T>
weak_ptr<T>::weak_ptr(const shared_ptr<T>& ptr):
	obj_{ptr.obj_},
	counter_{ptr.counter_}
{
	++counter_->weak_counter;
}

template <typename T>
weak_ptr<T>::weak_ptr(const weak_ptr& ptr) :
	obj_{ptr.obj_},
	counter_{ptr.counter_}
{
	++counter_->weak_counter;
}

template <typename T>
weak_ptr<T>::~weak_ptr() {
	if (--counter_->weak_counter && !counter_->shared_counter) {
		delete counter_;
	}
}

template <typename T>
shared_ptr<T> weak_ptr<T>::shared() {
	return counter_->shared_counter == 0 ? shared_ptr<T>() : shared_ptr<T>(obj_, counter_);
}






template <typename T>
shared_ptr<T>::shared_ptr(T* ptr) {
	obj_ = ptr;
	try {
		counter_ = new counter;
	} catch (...) {
		delete ptr;
	}
	counter_->shared_counter = 1;
	counter_->weak_counter = 0;
}

template <typename T>
shared_ptr<T>::shared_ptr(const shared_ptr& ptr) :
	obj_{ptr.obj_},
	counter_{ptr.counter_}
{
	++counter_->shared_counter;
}

template <typename T>
shared_ptr<T>::shared_ptr(T* obj, counter* counter) :
	obj_{obj},
	counter_{counter}
{
	++counter_->shared_counter;
}

template <typename T>
shared_ptr<T>::~shared_ptr() {
	dealloc();
}

template <typename T>
void shared_ptr<T>::dealloc() {
	if (counter_->shared_counter == 1 && counter_->weak_counter == 0) {
		delete counter_;
	} else {
		--counter_->shared_counter;
	}

	if (obj_ != nullptr) {
		delete obj_;
	}
}