Освобождение памяти в стандартном shared_ptr

template<typename T/*, typename D = default_delete<T>*/>
class Shared_ptr
{
    friend T* operator-> <>() const noexcept;
    friend T& operator* <>() const noexcept;
    public:
        constexpr Shared_ptr() noexcept :ptr(nullptr), cnt(new std::size_t(0)), 
                                         del(nullptr) { }
        constexpr Shared_ptr(nullptr_t):Shared_ptr() { }
        template<typename T>
        explicit Shares_ptr(T* p):ptr(p), cnt(new std::size_t(1)), del(nullptr) { }
        
        template<typename T, template D>
        Shared_ptr(T* obj, D d):ptr(obj), cnt(new std::size_t(1)), 
                                          del(d) { }
        
        template<template D>
        Shared_ptr(nullptr_t p, D d):ptr(p), cnt(new std::size_t(1)), 
                                          del(d) { }
                                          
        Shared_ptr(const Shared_ptr& r) noexcept :ptr(r.ptr), cnt(r.cnt), del(r.del) 
        { ++*r.cnt; }
        
        template<typename U>
        Shared_ptr(const Shared_ptr<U>& r) noexcept : ptr(r.ptr), cnt(r.cnt), 
                                                       del(r.del) { ++*r.cnt}
        
        Shared_ptr(Shared_ptr&& r) noexcept:ptr(std::move(r.ptr)), 
                                            cnt(std::move(r.cnt)),
                                            del(std::move(r.del))
        { }
        
        template<typename U>
        Shared_ptr(Shared_ptr<U>&& r) noexcept : ptr(std::move(r.ptr)),
                                                 cnt(std::move(r.cnt)),
                                                 del(std::move(r.del))
        { }
        
        
        
        ~Shared_ptr();
        
        Shared_ptr& operator=(const Shared_ptr&);
        Shared_ptr& operator=(Shared_ptr&&) noexcept;
        
        T* get() const noexcept { return ptr; }
        
        void reset() noexcept;
        template<typename T>
        void reset(T* p);
        
        template<typename T, typename D>
        void reset(T* p, D d);
        
        std::size_t use_count() const { return *cnt; }
        
    private:
        T* ptr;
        size_t* cnt;
        //std::function<void(T*)>& D;
        
};

template<typename T>
class data
{
    public:
        data():cnt(0), del(nullptr), w_cnt(0) { }
        data(nullptr_t):data() { }
        
    protected:
        counter cnt;
    //а как объявить объект удаления, что бы он работал и с deleter-ом по умолчанию и 
    //с заданным пользователем.
    void (*pDel)(T*) del; //Так не получается
    std::function(void (*)(T*)) del; //так, вроде бы, не подчёркивается красным, 
                                     //но в чём разница между void (*pDel)(T*); и 
                                     //std::function(void (*)(T*));
    weak_ptr<T> w_cnt;               //А это зачем?
};

class Counter
{
    //friend std::ostream& operator<<(std::ostream& os, const Counter& obj);
    //friend std::istream& operator>>(std::istream& is, Counter& obj);
public:
    constexpr Counter():cnt(new unsigned int(0)) { }
    //Counter(const unsigned int _cnt) { cnt = _cnt; }
    
    unsigned int get_count() const { return cnt; }
 
    Counter& operator++() noexcept
    {
        ++cnt;
        return (*this);
    }
    Counter operator++(int)
    {
        Counter tmp(*this);
        ++(*this);
        return tmp;
    }
 
    Counter& operator--() noexcept
    {
        --cnt;
        return (*this);
    }
    Counter operator--(int)
    {
        Counter tmp(*this);
        --(*this);
        return tmp;
    }
 
    
 
 
    bool operator==(const Counter& r) const
    {
        return (cnt == r.cnt);
    }
    bool operator!=(const Counter& r) const
    {
        return !(*this == r);
    }
 
    ~Counter() { delete cnt; }
 
    //void print() const;
private:
    unsigned int* cnt;
    
private:
    Counter(const Counter& r) = delete;
    Counter(Counter&& r) = delete;
    Counter& operator=(const Counter& r) = delete;
    Counter& operator=(Counter&& r) = delete;
};

#include <utility>
#include <cassert>
   
struct type_erasure
{
    virtual ~type_erasure(){}
    virtual void free(void*) = 0;
};
 
template<class t, class Fn> struct control: type_erasure
{
    control(Fn c) noexcept
        : m_call(std::move(c))
    {}
    
    virtual void free(void* raw)
    {
        assert(raw);
        t* resource = static_cast<t*>(raw);
        this->m_call(resource);
    }
    
private:
    // Здесь располагаем функцию удалятор, счетчики, и тп
    Fn m_call;
};
 
template<class t> struct smart_ptr
{
    // lambda - любой функтор, у которого имеется operator(t*)
    template<class lambda> smart_ptr(t* v, lambda call_delete)
        : m_res(v)
        , m_del(new control<t, lambda>(std::move(call_delete)))
    {}
    
    smart_ptr(const smart_ptr&)            = delete;
    smart_ptr& operator=(const smart_ptr&) = delete;
 
    ~smart_ptr()
    {
        assert(this->m_del);
        if(this->m_res)
            this->m_del->free(this->m_res);
        delete this->m_del;
    }
    
private:  
    t* m_res;
    type_erasure* m_del;
};
 
 
#include <iostream>
 
int main()
{
    const auto del = [](int* res) 
    {
        std::cout << "delete resource\n";
        delete res;
    };
    smart_ptr ptr(new int{1}, del);
}

void Free(int*){};
template <typename T>
class d{
    void (*pDel)(T*)=nullptr; //
public:
    void free(T*t){ if (pDel)(*pDel)(t);}
    void set(void (*d)(T*)){ pDel = d; }
};
 
d<int> a;
int empty;
void test() { a.free(&empty); a.set(Free); a.free(&empty); }