为什么 unique-ptr 不检查基类是否可虚拟破坏？

Question

考虑这个例子：

#include <cstdio>
#include <memory>

struct base
{
    base( int i ): i(i)    {    printf("base ctor\n"); }
    ~base() {     printf("base non-virtual dtor\n"); } // non-virtual
    int i;
};

struct derived : public base
{
    char* s;
    derived(int i): base(i), s(new char[i] )
    {
        printf("derived ctor\n");
    }
    ~derived()
    {
        printf("derived dtor\n");
        delete [] s;
    }
};

int main()
{
    printf("Success\n");

    //raw pointer
    printf("RAW-POINTER\n");
    {
        base* b = new derived(2);
         // ......
        delete b; //here memory leak, but it's old- and error-prone code.
    }
    printf("---END-RAW-POINTER--\n");

    //unique-ptr
    printf("UNIQUE_PTR\n");
    {
       // I would that, this doesn't compile, because base- has not virtual destructor.
        std::unique_ptr<base> bu( new derived(3) ); // here still memory leak !!!!
    }
    printf("--END-UNIQUE_PTR--\n");


    return 0;
}

代码std::unique_ptr<base> bu( new derived(3) ); 易于使用std::has_virtual_destructor 类型特征禁止。 Live code

那么为什么要编译上面的代码呢？这是标准允许的吗？

编辑：有趣，但 std::shared_ptr 有效，即基础和派生 dtor 都会调用：

    printf("SHARED_PTR\n");
    {
        std::shared_ptr<base> b(new derived(3));
    }
    printf("--END-SHARED_PTR--\n");

Output:
SHARED_PTR
base ctor
derived ctor
derived dtor
base non-virtual dtor
--END-SHARED_PTR--

为什么 std::shared_ptr 可以调用派生类 dtor，而 std::unique_ptr 不能？？？

EDIT2：简单我需要类似的东西：

template< typename T, typename D = default_deleter<T> >
class unique_ptr{
  .............

  template< typename U >
  unique_ptr( U* u ) if ( U != T && T - is class && T is base of U, and D - is default_deleter, and T - has not virtual destructor ) then = delete this ctor.

};

Answer 1

unique_ptr 和shared_ptr 之间的区别在于标准的语言，关于它们的析构函数（和构造函数）。适用于您的示例的两个智能指针的删除器的语言相似但略有不同：

[20.7.1.2.2] unique_ptr 析构函数 ...如果 get() == nullptr 没有效果。否则 get_deleter()(get())。 [20.7.2.2.2] shared_ptr 析构函数 ... 如果 *this 拥有一个对象 p 和一个删除器 d，则调用 d(p)。

您可以看到，在这两种情况下，标准都要求调用删除器，但在决定删除器的方式上有所不同，unique_ptr 删除了它通过get() 获得的 指针 ，而shared_ptr 删除对象。这种区别很重要。看看这两个类的构造函数也有什么不同：

shared_ptr 定义如下：

template <class  T> 
class  shared_ptr  {
...
    template<class  Y>  explicit  shared_ptr(Y*  p);

虽然unique_ptr 显式单参数构造函数是，

template <class  T, class D = default_delete<T>>
class  unique_ptr  {
...
    explicit  unique_ptr(pointer  p)  noexcept;
...

注意 unique_ptr 只是获取该类型的默认删除，在您的情况下将是普通的 delete，并存储指针。但是，shared_ptr<T> 构造函数不是在 T (!) 上模板化的，它是在构造它的对象 Y 上模板化的。因此，在您的场景中，

std::shared_ptr<base> b(new derived(3));

shared_ptr 将使用T=base 但Y=derived 构造，允许显式销毁派生对象，并且在您的示例中不会泄漏内存。

---

虽然您无法更改标准，但您可以做的是从项目中的unique_ptr 继承，或者提供您自己的包装器来强制执行所需的行为。例如，

namespace {
    template <class  T>
    struct checked_delete : public std::default_delete<T> {
        static_assert(std::has_virtual_destructor<T>::value, "");
    };    

    template <class T, class D = checked_delete<T>, class U>  
    std::unique_ptr<T, D>
    make_unique_ptr(U* p) { return std::unique_ptr<T, D>(p, D()); }    
}

// now this won't compile, because checked_delete<base> will not compile:
auto bu = make_unique_ptr<base>(new derived(3));

Answer 2

并非所有的 unique_pointers 都以多态方式使用：

std::unique_ptr<int> p(new int(42));

这将无法按照您建议的限制进行编译。与类相同：

std::unique_ptr<YourClassHere> p(new YourClassHere);