Использование enable_shared_from_this совместно с custom deleter

#include <cassert>
#include <utility>
 
class IRefCnt
{
public:
    virtual void addRef() = 0;
    virtual void remRef() = 0;
};
 
template <typename IObj>
class RefCnt : public IObj
{
protected:
    RefCnt() : m_refCnt()
    {}
 
    void addRef() override
    {
        ++m_refCnt;
    }
    void remRef() override
    {
        if(--m_refCnt == 0)
        {
            delete this;
        }
    }
 
private:
    int m_refCnt;
};
 
template <typename IObj>
class RefCntPtr
{
public:
    RefCntPtr(IObj* p = nullptr) : m_ptr(p)
    {
        if(m_ptr) m_ptr->addRef();
    }
    ~RefCntPtr()
    {
        if(m_ptr) m_ptr->remRef();
    }
    RefCntPtr(RefCntPtr const& other) : m_ptr(other.m_ptr)
    {
        if(m_ptr) m_ptr->addRef();
    }
    RefCntPtr& operator=(RefCntPtr const& other)
    {
        if(this != &other)
            RefCntPtr(other).swap(*this);
        return *this;
    }
    void swap(RefCntPtr& other)
    {
        std::swap(m_ptr, other.m_ptr);
    }
 
    IObj* operator->()
    {
        assert(m_ptr != nullptr);
        return m_ptr;
    }
    
private:
    IObj* m_ptr;
};
 
class ISomeDll;
 
extern "C" ISomeDll* createSomeDll();
 
class ISomeDll : public IRefCnt
{
public:
    using IPtr = RefCntPtr<ISomeDll>;
 
    IPtr demo() // NVI
    {
        return IPtr( this );
    }
    static IPtr create()
    {
        return IPtr( createSomeDll() );
    }
 
    virtual void test() = 0;
 
protected:
    virtual ~ISomeDll() = default;
};
 
//........................
// cpp
#include <iostream>
 
class SomeDll : RefCnt<ISomeDll>
{
    friend ISomeDll* createSomeDll();
public:
    void test() override
    {
        std::cout << "SomeDll::test\n";
    }
    ~SomeDll()
    {
        std::cout << "SomeDll destroyed\n";
    }
};
 
ISomeDll* createSomeDll()
{
    return new(std::nothrow) SomeDll();
}
 
int main()
{
    ISomeDll::IPtr p = ISomeDll::create();
 
    p->test();
 
    ISomeDll::IPtr p1 = p->demo();
 
    p1->test();
}