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;
}