Boost logo

Boost :

From: Joe Gottman (jgottman_at_[hidden])
Date: 2004-08-19 20:09:07

   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

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

        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

Joe Gottman

Boost list run by bdawes at, gregod at, cpdaniel at, john at