lightweight shared pointer

lightweight shared pointer

#include <stdio.h>
#include <new>

template <typename T>
struct lw_shared_ptr {

	struct Mem {
		int counter;
		T value;
	};
	Mem *_mem;

	void destroy() {

		if (_mem != nullptr) {
			--_mem->counter;

			if (_mem->counter == 0) {
				(&_mem->value)->~T();
				::operator delete(_mem);
			}
			_mem = nullptr;
		}
	}
	template <typename U> void
	init(lw_shared_ptr<U> &rhs) {

		_mem = (lw_shared_ptr<T>::Mem *)(void *) rhs._mem;
		if (_mem != nullptr) {
			_mem->counter++;
		}
	}

	lw_shared_ptr(const T& t)
		: _mem((Mem *)::operator new(sizeof(Mem))) {

		_mem->counter = 1;
		new (&_mem->value) T(t);
	}


	template <typename U>
	lw_shared_ptr(lw_shared_ptr<U> &rhs) {

		init(rhs);
	}

	template <typename U> lw_shared_ptr<T>& operator=(lw_shared_ptr<U> &rhs) {

		destroy();
		init(rhs);
		return *this;
	}

	~lw_shared_ptr() {
		destroy();
	}
};

struct Base {
	Base() {
		printf("%p::Base()\n", this);
	}
	virtual ~Base() {
		printf("%p::~Base()\n", this);
	}
};

struct Derived: public Base {
	virtual ~Derived() {
		printf("%p::~Dervied\n", this);
	}
};

int main() {
	auto foo = lw_shared_ptr<Base>(Base());

	auto bar = lw_shared_ptr<Derived>(Derived());

	foo = bar;
	return 0;
}