Does the standard behavior for deleters differ between shared_ptr and unique_ptr in the case of null pointers?

Question

OK, so first some things that might be relevant:

I\'m using the Clang 3.1 compiler, in C++11 mode, with the standard library set to libc++.

I\'m trying to fa

Answer 1

Yes it is the correct behavior.

§20.7.1.2.2[unique.ptr.single.dtor]/2:

unique_ptr destructor

Effects: If get() == nullptr there are no effects. Otherwise get_deleter()(get()).

§20.7.2.2.2[util.smartptr.shared.dest]/1:

shared_ptr destructor

Effects:

• If *this is empty or shares ownership with another shared_ptr instance (use_count() > 1), there are no side effects.
• Otherwise, if *this owns an object p and a deleter d, d(p) is called.
• Otherwise, *this owns a pointer p, and delete p is called.

So there should be no effect since the shared_ptr is empty? Wrong, because providing the a pointer makes the shared_ptr not empty, even if the pointer is null.

§20.7.2.2.1[util.smartptr.shared.const]/8–10

shared_ptr constructors

template shared_ptr(Y* p, D d);
template shared_ptr(Y* p, D d, A a);
template  shared_ptr(nullptr_t p, D d);
template  shared_ptr(nullptr_t p, D d, A a);

Requires: p shall be convertible to T*. …

Effects: Constructs a shared_ptr object that owns the object p and the deleter d.

Postconditions: use_count() == 1 && get() == p.

This means the shared_ptr owns the nullptr. Thus the deleter will be called when the shared_ptr is destroyed.