Избегайте нарезки объектов для невиртуальных деструкторов

Вашему умному указателю нужны 3 блока информации.

Во-первых, указатель на данные (T* или что-то в этом роде).

Во-вторых, ваш счетчик ссылок: std::atomic<int> или что-то в этом роде.

В-третьих, ваша функция разрушения (std::function<void(T*)> или что-то в этом роде).

Когда интеллектуальный указатель создается впервые, создается эта функция уничтожения. Когда ваш интеллектуальный указатель копируется в другой интеллектуальный указатель, эта функция уничтожения копируется. Если тип нового интеллектуального указателя не совпадает со старым, эта функция уничтожения оборачивается совместимым с типом способом (работает ли std::function<void(Base*)> = std::function<void(Derived*)> из коробки? Независимо от того, вы в основном делаете это).

По умолчанию эта функция уничтожения просто delete t, но в качестве дополнительного преимущества это позволяет пользователям вашего интеллектуального указателя передавать функцию уничтожения, которая не всегда delete t.

Забавно, но на эквиваленте reset вы заменяете свою функцию уничтожения. Таким образом, вы могли бы сделать сигнатуру функции уничтожения std::function<void()>, что немного упрощает ее перемещение между интеллектуальными указателями типа T и U.

template < typename T > class SP
{
private:
  T*    pData;       // pointer
  RC* reference; // Reference count
  std::function<void()> destroyData;
public:
  template<typename U>
  SP(U* pValue):
    pData(pValue),
    reference(nullptr),
    // store how to destroy pValue now, for later execution:
    destroyData([pValue]()->void{
      delete pValue;
    })
  {
    // Create a new reference 
    reference = new RC();
    // Increment the reference count
    reference->AddRef();
  }
  // similar for operator=, and you may have to do something for SP<T> as well:
  template<typename U>
  SP(const SP<U>& sp):
    pData(sp.pData),
    reference(sp.reference),
    destroyData(sp.destroyData)
  {
    // Copy constructor
    // Copy the data and reference pointer
    // and increment the reference count
    reference->AddRef();
  }
  template<typename U>
  SP<T>& operator = (const SP<U>& sp)
  {
    // blah blah blah, then
    destroyData = sp.destroyData;
  }

  ~SP()
  {
    // Destructor
    // Decrement the reference count
    // if reference become zero delete the data
    if(reference->Release() == 0)
    {
        delete reference;
        destroyData(); // here I destroyed it!
    }
  }
};

или что-то вроде того

Альтернативный подход предполагает делегирование удаления другому классу.

// non templated base
class DeleterBase {
    public:
        virtual ~DeleterBase() { };
};

template <typename T>
class Deleter : public DeleterBase {
    private:
        T *ptr;
    public:
        Deleter(T *p) // remember the pointer with the correct type here
            : ptr{p}
        { }

        ~Deleter() { 
            delete this->ptr; // invokes correct destructor
        }
};

now in the smart pointer:

template <typename T>
class SP {
    private:
        T *p;
        DeleterBase *deleter;
    public:
        template <typename U> // U is deduced to actual type
        explicit SP(U *p)
            : p{p},
            deleter{new Deleter<U>(p)} // correct type
        { }

        // transfer control in the move constructor/assignment
        // increase the ref count in copy constructor/assignment

        // now just delete the deleter in the dtor
        ~SP() {
            if (reference_count_is_zero()) { // however you implement this
                delete this->deleter;
            }
        }
};

Поскольку у вас уже есть класс RC, вы можете перенести показанные здесь функции в этот класс. Сделайте этот класс шаблонным с нешаблонной базой и уничтожьте указатель, когда его счетчик ссылок будет удален. Одной вещью меньше.