Re: N2369 library defect: Const-incorrect get_deleter function for
shared_ptr
Daniel Kr=C3=BCgler ha scritto:
template<class D, class T> D* get_deleter(shared_ptr<T> const& p);
<snip>
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);
If we want to follow the example of unique_ptr, then we might also
consider making get_deleter() a member function, instead of a free
function. I guess the rationale in Boost was to make a pair with the
free function get_pointer(), but the latter has not been included in the
latest draft...
(B) Provide *only* the immutable variant. This would reflect the
current
praxis of container::get_allocator(), map::key_comp(), or
map::value_comp.
Actually all those functions return a copy of the allocator/comparator.
That is good, because by returning a pointer or reference the user will
still have some level of access to the object that may be undesirable
(even const will not prevent the user to use const_cast).
Unfortunately we can't do that for shared_ptr, because get_deleter()
might fail if the deleter has the wrong type.
template<class D, class T> const D* get_deleter(shared_ptr<T> const&
p);
(C) Just remove the function.
All three options have some value in it, IMHO. There is one more option
that might be considered:
(D) Replace it with two functions:
template <class D, class T> D get_deleter(shared_ptr<T> const&);
template <class D, class T> bool has_deleter(shared_ptr<T> const&);
The first one would throw if D is the wrong type, while the latter would
never throw. This approach would reflect the current praxis of
use_facet/has_facet, with the twist of returning the deleter by value as
container::get_allocator() do.
Just out of curiosity, I did a search on Google Code for get_deleter. I
got only 23 hits, most of which were declarations (as term of
comparison, shared_ptr returned 500 hits). Only few hits were actually
uses of get_deleter:
- a use in Boost.Python, for converting shared_ptr to some python-aware
smart pointer
- a use in make_shared, which don't count because make_shared could
actually be made friend of shared_ptr
- a couple of uses for diagnostic purposes, one of which in the
shared_ptr test suite itself
The first use is the only one really interesting, IMHO. Actually, the
code only checked if the result of get_deleter() was NULL or not, it did
not use the returned value in any other way. This use would be
compatible with options (A), (B) and (D).
Just my two eurocent,
Ganesh
---
[ 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 ]