clang & gcc don't warn about non-virtual base destructors for polymorphism when using smart pointers?

Question

We know that ~~if there are virtual functions then the base class destructor should be marked as virtual as well, otherwise it is undefined behavior when explicitly deleted with base class pointer~~ if we hope to delete derived object with base class pointer the base destructor should be marked as virtual, otherwise it is undefined behavior.

For example,

struct Base {
  virtual void greet() { std::cout << "base\n"; }
};

struct Derived : public Base {
  virtual void greet() override { std::cout << "derived\n"; }
};

call

Base *b = new Derived;
b->greet();
delete (b);

clang(gcc similarly) will emit such a warning when -Wdelete-non-virtual-dtor:

delete called on 'Base' that has virtual functions but non-virtual destructor

But neither of them report warnings for smart pointers:

std::unique_ptr<Base> sb = std::make_unique<Derived>();
//   std::unique_ptr<Base> sb = std::unique_ptr<Derived>(new Derived);
sb->greet();

I guess this still leads to undefined behavior, right?

Well, your first sentence lumps up several unrelated things. The rule is that deleting derived class through base class pointer is UB if the destructor is non-virtual. That's all there is to it. Whether the class has any other virtual functions is completely irrelevant. Presence of other virtual functions is just a loose rule-of-the-thumb criterion that suggests that this class is relatively likely to be deleted through a base class pointer. — AnT
@AndreyT thanks for pointing out that, i updated the original question to avoid misunderstanding. But I just discover that gcc/clang won't emit warnings if no virtual functions called, why? — Hongxu Chen

T.C. T.C. · Accepted Answer · 2014-10-12T02:52:00

Yes, it's still undefined behavior. The problem is that the delete call happens inside std::default_delete, which is inside a system header. By default, the compiler doesn't generate warnings for code in system headers.

If you pass -Wsystem-headers, you'll see the warning. Unfortunately, it's buried inside a pile of other warnings.

clang & gcc don't warn about non-virtual base destructors for polymorphism when using smart pointers?

3 Answers