The following issue was raised by Alf P. Steinbach in c.l.c++.mod:

According to the recent draft N2369, both the header memory synopsis
of [memory] and [util.smartptr.getdeleter] declare:

template<class D, class T> D* get_deleter(shared_ptr<T> const& p);

This allows to retrieve the pointer to a mutable deleter of a const
shared_ptr (if that owns one) and therefore contradicts the usual
philosophy that associated functors are either read-only (e.g.
key_comp or value_comp of std::map) or do at least reflect
the mutability of the owner (as seen for the both overloads of
unique_ptr::get_deleter).
Even the next similar counter-part of get_deleter - the two
overloads of function::target in the class template function
synopsis [func.wrap.func] or in [func.wrap.func.targ] - do
properly mirror the const-state of the owner.

Proposed resolution:

Replace the declarations of get_deleter in the header <memory>
synopsis of [memory] and in [ util.smartptr.getdeleter] by one of the
following alternatives (A), (B), or (C):

(A) A pair of overloads which preserve the constness of the owning
shared_ptr (This reflects the praxis existing for
unique_ptr::get_deleter):

template<class D, class T> const D* get_deleter(shared_ptr<T> const&
p);
template<class D, class T> D* get_deleter(shared_ptr<T>& p);

(B) Provide *only* the immutable variant. This would reflect the
current
praxis of container::get_allocator(), map::key_comp(), or
map::value_comp.

template<class D, class T> const D* get_deleter(shared_ptr<T> const&
p);

(C) Just remove the function.

---
[ comp.std.c++ is moderated.  To submit articles, try just posting with ]
[ your news-reader.  If that fails, use mailto:std-c++@ncar.ucar.edu    ]
[              --- Please see the FAQ before posting. ---               ]
[ FAQ: http://www.comeaucomputing.com/csc/faq.html                      ]