C++ shared_ptr deleter的实现

#include <iostream>
#include <memory>
using namespace std;

#include<iostream>
class sp_base{
public:
    virtual void del(void* obj) = 0;
    void inc_ref(){
        ref_count_++;
    }
    void dec_ref(){
        ref_count_--;
    }
    int ref_count()const{
        return ref_count_;
    }
private:
    int ref_count_ = 1;
};
template<typename T, typename D>
class sp_impl : public sp_base{
public:
    sp_impl(D d):d_(d){}
    void del(void* obj){
        d_((T*)obj);
    }
private:
    D d_;
};

template<typename T>
class default_del{
public:
    void operator()(T* obj){
        std::cout << "sizeof (T) = " << sizeof(T) << std::endl;
        delete obj;
    }
};

template<typename T>
class sh_ptr{
public:
    template<class U> explicit sh_ptr(U* p){
        obj = (T*)p;
        sp = new sp_impl<U, default_del<U>>(default_del<U>());
    }
    template<class U, class D> sh_ptr(U* p, D del){
        obj = (T*)p;
        sp = new sp_impl<U, D>(del);
    }
    sh_ptr(const sh_ptr& x){
        obj = x.obj;
        sp = x.sp;
        sp->inc_ref();
    }
    template <class U> sh_ptr(const sh_ptr<U>& x){
        obj = (T*)x.obj;
        sp = x.sp;
        sp->inc_ref();
    }
    ~sh_ptr(){
        sp->dec_ref();
        if(sp->ref_count() == 0){
            sp->del(obj);
        }
    }
private:
    T* obj;
    sp_base* sp;
};

class Base{
public:
    Base(int b):m(b){}
    ~Base(){
        std::cout << "deconctructor b" << std::endl;
    }
private:
    int m;
};

void delBase(Base* b){
    delete b;
}

class delFunctor{
public:
    void operator()(Base* b){
        delete b;
    }
};
int main(){

    {
        sh_ptr<Base> si = sh_ptr<Base>(new Base(5), delBase);
        sh_ptr<Base> si2 = sh_ptr<Base>(new Base(4), delFunctor());
        sh_ptr<Base> si3 = sh_ptr<Base>(new Base(3), [](Base* b){delete b;});
    }

    return 0;
}