避免对非虚拟析构函数进行对象切片

Question

我正在为智能指针编写代码作为练习。使用在线教程（1，2）我开发了一个普通的带引用计数的智能指针类。问题是我无法弄清楚以下内容：

当智能指针检测到不再存在对某个 特定对象，它必须通过指向该对象的指针删除该对象 原始类型，即使最终智能的模板参数 指针是基本类型。这是为了避免对象切片 非虚拟析构函数。

我怎样才能做到这一点。基本上我的代码如下所示（来自教程）。

template < typename T > class SP
{
private:
    T*    pData;       // pointer
    RC* reference; // Reference count

public:
    SP() : pData(0), reference(0) 
    {
        // Create a new reference 
        reference = new RC();
        // Increment the reference count
        reference->AddRef();
    }

    SP(T* pValue) : pData(pValue), reference(0)
    {
        // Create a new reference 
        reference = new RC();
        // Increment the reference count
        reference->AddRef();
    }

    SP(const SP<T>& sp) : pData(sp.pData), reference(sp.reference)
    {
        // Copy constructor
        // Copy the data and reference pointer
        // and increment the reference count
        reference->AddRef();
    }

    ~SP()
    {
        // Destructor
        // Decrement the reference count
        // if reference become zero delete the data
        if(reference->Release() == 0)
        {
            delete pData;
            delete reference;
        }
    }

    T& operator* ()
    {
        return *pData;
    }

    T* operator-> ()
    {
        return pData;
    }
    
    SP<T>& operator = (const SP<T>& sp)
    {
        // Assignment operator
        if (this != &sp) // Avoid self assignment
        {
            // Decrement the old reference count
            // if reference become zero delete the old data
            if(reference->Release() == 0)
            {
                delete pData;
                delete reference;
            }

            // Copy the data and reference pointer
            // and increment the reference count
            pData = sp.pData;
            reference = sp.reference;
            reference->AddRef();
        }
        return *this;
    }
};

编辑：

为了实现这一点，我必须有一个指向原始类型的指针。

我在这里发布了一个问题：delete via a pointer to Derived, not Base

但是现在自从查看 cmets 和答案后，我认为两者都是相关的。我有构造函数：

template <typename T>
template <typename U>
Sptr<T>::Sptr(U* u) : obj(u),ref(NULL) {
    //do something
    ref = new RC();
    ref->AddRef();
}

现在考虑Sptr<Base1> sp(new Derived);，其中Derived 派生自Base1。 Base1 具有受保护的构造函数/析构函数。 这是为 T 类型的对象存储的，但我需要通过 U 类型的对象来存储它。我需要保留它。我该怎么做？

Answer 1

您的智能指针需要 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!
    }
  }
};

或者类似的东西

Answer 2

另一种方法是将删除委托给另一个类

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

现在在智能指针中：

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 类，您可以将我在此处展示的功能移到该类中。使该类使用非模板基数模板化，并在删除引用计数时销毁指针。少一件要传递的东西。