template<typename T> class shared_ptr {
    struct deleter_base {
        unsigned strongrefs;
        virtual void destroy(T* p) = 0;
        virtual ~deleter_base() {}
    };
    template<typename Del> struct deleter_derived : public deleter_base {
        deleter_derived(Del del) : d(std::move(del)) {}
        Del d;
        void destroy(T* p) { d(p); }
    };
    struct unique_deleter {
        unique_deleter(unique_deleter&& other)
        : d(nullptr) {
            std::swap(d, other.d);
        }

        unique_deleter(deleter_base* d)
        : d(d) {
            if (!d) return;
            d->strongrefs++;
        }

        deleter_base* d;
        void operator()(T* p) {
            if (!d) return;
            if (! --d->strongrefs) {
                d->destroy();
                delete d;
            }
        }
    };
    std::unique_ptr<T, unique_deleter> ptr;
public:
    shared_ptr() {}
    shared_ptr(const shared_ptr& other)
        : ptr(other.get(), other.ptr.get_deleter().d) {}
    shared_ptr(shared_ptr&& other)
        : ptr(std::move(other.ptr)) {}

    shared_ptr& operator=(const shared_ptr& other) {
        ptr = std::unique_ptr<T, unique_deleter>(other.get(), other.ptr.get_deleter().d);
    }
    shared_ptr& operator=(shared_ptr&& other) {
        ptr = std::move(other.ptr);
    }

    shared_ptr(T* p) {
        auto destruct = [](T* ptr) { delete ptr; };
        ptr = std::unique_ptr<T, unique_deleter>(p, new deleter_derived<decltype(destruct)>(destruct);
    }

    explicit operator unique_ptr<T, unique_deleter>() {
        return unique_ptr<T, unique_deleter>(ptr.get(), ptr.get_deleter().d);
    }
};