C++: std::shared_ptr<void>

I recently came across a use of std::shared_ptr that surprised me. It began with a line of code that looked like this…

std::shared_ptr<void> sp = std::make_shared<SomeType>();

This completely blew my mind. “You can’t parameterize shared_ptr with void! There’s no way that’ll work!” I proclaimed loudly. I explained that the shared_ptr will try to delete a void pointer and bad things will happen. The standard says this about deleting a void pointer…

C++ 17 Standard Working Draft, Section 8.3.5: ...an object cannot be deleted using a pointer of type void* because void is not an object type.

You can’t argue with that, right? Obviously, the author of the aforementioned line of code had lost his marbles.

Or had they. The thing was, this line of code actually worked. Was it accidental? Was it a quirk of the compiler? Hmmmm….something else was going on here.

It turned out that std::shared_ptr had a few tricks up its sleeve that I was completely unaware of.

Why It Works

When the default deleter is created for a shared_ptr, it captures the type of the managed object independently of the type that shared_ptr is actually parameterized with. It’s as simple as that. The deleter knows about the actual type.

The deleter also happens to be type erased. (If type erasure is unfamiliar to you, check out the links I include at the bottom of this article.) This allows things like assignments, moves, etc. between shared_ptrs parameterized with the same managed object type, but containing different deleter types (lambdas, function pointers, functors, etc.). As long as the managed object type is the same, two shared_ptr are considered to be of the same type and you can assign one to the other with no problem.

Let’s look at a very simple example that captures the spirit of what’s happening under the hood of shared_ptr. We’ll create our own scoped pointer that allows for custom deleters.

Let’s first stub out a basic naive ScopedPtr class.

template<typename T> 
class ScopedPtr
{
public:
 
    ScopedPtr(T *pT, SomeDeleterType deleter) : 
        m_pT(pT), m_deleter(deleter) {}
 
    ~ScopedPtr() 
    { 
        m_deleter(m_pT);
    }
 
    T * get() { return m_pT; }
 
private:
 
    T *m_pT; // Managed object
 
    SomeDeleterType m_deleter;
 
    ScopedPtr(const ScopedPtr &) = delete;
    ScopedPtr & operator=(const ScopedPtr &) = delete;
};

Just like shared_ptr, this template is parameterized with the type of the object it’s intended to manage. You can pass a pointer to an object of that type into the constructor. The constructor also accepts a deleter parameter. But we don’t know what that’s going to look like just yet. In this snippet of code, I simply call it SomeDeleterType.

There are two member variables in ScopedPtr – the object being managed and the deleter.

The destructor does as you might expect. It calls the deleter with the managed object.

Side note: I explicitly deleted the copy constructor and assignment operators here because I wanted to avoid introducing the problems associated with auto_ptr.

Now we just need to decide what we want the deleter to look like. We have three requirements – a) It must be type erased, and b) It must be invokable, accepting a pointer to the managed object to delete, and c) It must delete an object using the correct type.

We could create a Deleter interface class with an operator() that accepts a void pointer. All deleter implementations, including the default deleter, would need to inherit from it. However, we want to support a variety of invokable types (lambdas, function pointers, function objects, etc.). And I don’t want to work too hard to make that happen. Fortunately, the standard library provides a super-easy mechanism to do this – std::function.

template<typename T> 
class ScopedPtr
{
public:
    using Deleter = std::function<void (void *)>;
 
    ScopedPtr(T *pT, Deleter deleter) : 
        m_pT(pT), m_deleter(deleter) {}
 
    ~ScopedPtr() 
    { 
        m_deleter(m_pT);
    }
 
    T * get() { return m_pT; }
 
private:
 
    T *m_pT; // Managed object
 
    Deleter m_deleter;
 
    ScopedPtr(const ScopedPtr &) = delete;
    ScopedPtr & operator=(const ScopedPtr &) = delete;
};

In this snippet, we’ve created a type alias to std::function<void (void*)> called Deleter. Now our constructor can accept any invokable type as a deleter.

For instance, this will do exactly what we expect it to.

ScopedPtr<int> ptr(new int(0), 
    [&](void *pObj) { delete static_cast<int *>(pObj); });

And so will this…

ScopedPtr<void> ptr(new int(0), 
    [&](void *pObj) { delete static_cast<int *>(pObj); });

Note that in the last example even though we parameterize ScopedPtr with void, our deleter casts the managed object to a int * before deleting it. This is the kind of thing we want the default deleter to do on our behalf.

We’re almost there. The one thing missing is the default deleter. This is where the magic needs to happen. Let’s first create a generic deleter template class.

template <typename ManagedObjectType>
class DefaultDeleter
{
public:
    void operator()(void *pV)
    {
        delete static_cast<ManagedObjectType *>(pV); 
    }
};

So far so good.

Now our ScopedPtr constructor could be augmented like this.

ScopedPtr(T *pT, Deleter deleter = DefaultDeleter<T>()) : 
    m_pT(pT), m_deleter(deleter) {}

However, there’s a problem here. The DefaultDeleter template is parameterized with the same type as ScopedPtr. If that type happens to be void, the deleter will also be parameterized with void and try to delete a void pointer. And that’s the very problem we’re trying to solve.

What we want is for the DefaultDeleter to be parameterized with the actual type of the managed object. It sounds tricker than it is. All we really need to do is make ScopePtr’s constructor a template function and leverage a little type deduction.

template<typename T2>
ScopedPtr(T2 *pT, Deleter deleter = DefaultDeleter<T2>()) : 
    m_pT(pT), m_deleter(deleter) {}

When the constructor is called, T2 is deduced to be of whatever type the pT argument happens to be. And that’s what the DefaultDeleter ends up being parameterized with as well. That can be different than the type the ScopePtr class is parameterized with.

If we pass in an int pointer for pT, the default deleter’s type will be of type DefaultDeleter<int>.

ScopePtr’s member variable m_pT is of type T *. Remember, its type comes from the template classes’s type parameters. If the T in ScopePtr<T> is covariant with whatever is passed into the constructor (void is effectively pointer-compatible with everything), all is well.

For example…

ScopedPtr<void> ptr(new int(0));

In the above snippet, the ScopePtr’s variable m_pT is of type void *, while m_deleter wraps a DefaultDeleter<int>. So the int will be properly deallocated when the ScopedPtr goes out of scope.

The complete implementation of our ScopedPtr looks like this…

template<typename T> 
class ScopedPtr
{
 
private:
 
    template <typename ManagedObjectType>
    class DefaultDeleter
    {
    public:
        void operator()(void *pV)
        {
            delete static_cast<ManagedObjectType *>(pV); 
        }
    };
 
public:
 
    using Deleter = std::function<void (void *)>;
 
    template<typename T2>
    ScopedPtr(T2 *pT, Deleter deleter = DefaultDeleter<T2>()) : 
        m_pT(pT), m_deleter(deleter) {}
 
    ~ScopedPtr() 
    { 
        m_deleter(m_pT);
    }
 
    T * get() { return m_pT; }
 
private:
 
    T *m_pT; // Managed object
 
    Deleter m_deleter;
 
    ScopedPtr(const ScopedPtr &) = delete;
    ScopedPtr & operator=(const ScopedPtr &) = delete;
};

Our implementation of ScopedPtr is, of course, pretty barebones. If you want to support move semantics, for example, you’ll need to provide your own move constructor and move assignment operator. The default implementations won’t work because m_pT isn’t guaranteed to be set to nullptr in the moved-from object, which causes the deleter to blow up once the ScopePtr has been moved-from. That’s a detail unconcerned with this discussion. All of this was just to illustrate the concept of what’s going on under the hood in shared_ptr.

Ok, So What’s shared_ptr<void> Actually Good For?

Given that shared_ptr<void> doesn’t actually store any type information, you might wonder what utility such a thing might have. There are a few scenarios that come to mind where I envision it could possibly maybe be useful.

For example, many C-style callback mechanisms often take two pieces of information from the client – a callback function and a piece of userdata, which is often accepted/delivered as a void *. I can MAYBE imagine perhaps a more “modern” C++-ish approach could instead used a shared_ptr<void> or a unique_ptr<void> to shuttle around such userdata. That’s not to say that the code wouldn’t smell. If there’s no transfer of ownership, you’d probably be better off using naked pointer or references.

The second scenario involves implementing a garbage collector of sorts. Imagine two threads – a producer and a consumer of various heterogenous types of data. The producer thread is low priority, and has the liberty to allocate memory whenever it sees fit. The consumer of the data is a high-priority, real-time thread (think real-time audio processing). These types of threads typically can’t afford any sort of waiting/locking, which includes memory allocation/deallocation. In that case, you might want to implement a garbage collector of sorts that allows the deallocation of data to happen somewhere else other than the high-priority thread. std::shared_ptr<void> could be useful for this.

Conclusion

If nothing else, std::shared_ptr<void> is an interesting case study of the type-erasure idiom. Learning how the deleter works has given me the confidence to use C++11 smart pointers when working with APIs that use types employing C-style subtyping (Win32 is chock full of these).

Usage of std::shared_ptr<void> is a bit of a code smell, I think. If you feel compelled to use it, I suggest perhaps asking yourself if there’s a better way to do whatever it is you’re trying to accomplish.

Type-Erasure Related Links

C++ type erasure
C++ ‘Type Erasure’ Explained
Andrzej’s C++ blog – Type erasure — Part I
Andrzej’s C++ blog – Type erasure — Part II
Andrzej’s C++ blog – Type erasure — Part III
Andrzej’s C++ blog – Type erasure — Part IV

Leave a Reply

Your email address will not be published. Required fields are marked *

*