I know this isn't the best time to request a new feature, but I just had
an idea for an extremely useful new function for shared_ptr. It is common
to use a shared_ptr<void> in places where a void * would otherwise be used.
While a void * can point to anything, there is no safe way to determine at
run-time what type it originally pointed to. Casting it to the wrong type
can result in undefined behavior.
Although there's no way to avoid this problem with a plain void *, except
by passing type information along with it, it should be possible to improve
on this situation for shared_ptr<void>, using the template function
void_pointer_cast.
template<class X>
shared_ptr<X> void_pointer_cast(shared_ptr<void> pv);
(and similarly for shared_ptr<const void>, shared_ptr<volatile void> and
shared_ptr<const volatile void>)
void_pointer_cast should have the following semantics:
if (pv.get() && pv owns an object of type X) {
return shared_pointer_cast<X>(pv);
} else {
return shared_ptr<X>();
}
This would allow code like the following
shared_ptr<void> pv = getNextObject();
if (shared_ptr<int> pInt = void_pointer_cast<int>(pv)) {
// Do something with pInt;
} else if (shared_ptr<string> pString = void_pointer_cast<string>(pv)) {
// Do something with pString;
}
Note that while this code is very similar to code using
dynamic_pointer_cast, void_pointer_cast would be usable even when the target
type is not a class with virtual functions. On the other hand, given code
like
shared_ptr<void> pv(new Derived);
shared_ptr<Base> pb = void_pointer_cast<Base>(pv);
pb.get() would equal 0, even if Base were a public base class of Derived and
had a virtual destructor.
void_pointer_cast should be easy to implement, using the same techniques
as were used in get_deleter, and I think it would be of great use to many
programmers.
Joe Gottman
