Efficiently erase a unique_ptr from an unordered_set

Question

I am storing the ownership of some objects inside an unordered_set, using unique_ptrs. But I don't know a good way to erase one of them from the set, when the time comes.

Code looks something like this:

typedef unique_ptr<MyType> MyPtr;

unordered_set<MyPtr> owner;

MyPtr p = make_unique<MyType>("foo")
MyType *pRaw = p.get();
owner.insert(std::move(p));

// Later ...

// I want to do something like this (cannot be written as-is, of course):
// owner.erase(pRaw);

Is there a way to do this? I can, of course, iterate the entire set with begin() and end(), but the whole point of putting them in the set is to make these lookups efficient.

Some things I have thought of already:

• Use shared_ptr. This is the wrong abstraction for my case. Ownership is unique.
• Use raw pointers, and forget about unique_ptr. This abandons all the advantages that unique_ptr provides.
• Find the bucket with unordered_set::begin(key). As far as I know, there is no way for me to create a key that will match the unique_ptr I want to delete. But I'm happy to be proven wrong (:

(In truth, I solved this using eastl::unordered_set, with its find_as function for custom keys)

Answer 1

I came up with a better solution with a hash-based lookup for the general case that's exception-safe and doesn't require a local lambda as a deleter, or a separate release helper to call it. It also doesn't require C++20 or restrictions on the hash and equal functions:

/*
 * Behaves like an std::unique_ptr that
 * does not delete the pointer on destruction
*/
template<typename T>
class bad_ptr
{
private:
    std::unique_ptr<T> m_ptr;

public:
    // construct from a pointer
    bad_ptr(T* ptr) : m_ptr{ptr} { }

    // convert to an std::unique_ptr&
    operator const std::unique_ptr<T>&() {
        return m_ptr;
    }

    // release the pointer without deleting it
    ~bad_ptr() {
        m_ptr.release();
    }
};

Usage:

struct test_struct {
    int a;
    int b;
};

int main()
{
    std::unordered_set<std::unique_ptr<test_struct>> set;
    auto raw_ptr = set.insert(std::make_unique<test_struct>(1, 2)).first->get();

    // error
    // set.erase(raw_ptr);

    // works
    set.erase(bad_ptr{raw_ptr});
}

So that you would simply

owner.erase(bad_ptr{pRaw});

The bad_ptr is perhaps a misnomer, but I find this much cleaner and easily re-usable especially if you have to erase lots of unique_ptrs from sets or unordered_sets.

Answer 2

In C++20, std::unordered_set::find can use equivalent key with transparent hash and KeyEqual, then you might do something similar to:

struct MyHash
{
    using is_transparent = void;

    auto operator()(MyType* p) const { return std::hash<MyType*>{}(p); }
    auto operator()(const MyPtr& p) const { return std::hash<MyType*>{}(p.get()); }
};

struct MyEqual
{
    using is_transparent = void;

    template <typename LHS, typename RHS>
    auto operator()(const LHS& lhs, const RHS& rhs) const
    {
        return AsPtr(lhs) == AsPtr(rhs);
    }
private:
    static const MyType* AsPtr(const MyType* p) { return p; }
    static const MyType* AsPtr(const MyPtr& p) { return p.get(); }

};

int main()
{
    std::unordered_set<MyPtr, MyHash, MyEqual> owner;

    MyPtr p = std::make_unique<MyType>();
    MyType *pRaw = p.get();
    owner.insert(std::move(p));

    auto it = owner.find(pRaw);
    if (it != owner.end()) {
        owner.erase(it);
    }
}

Answer 3

This is a tough case. erase has an overload that takes a const key_type& parameter, so we can try to create a "stale" unique_ptr to get the hash value of the element to be erased:

template <typename T>
auto erase(std::unordered_set<std::unique_ptr<T>>& set, T* ptr)
{
    std::unique_ptr<T> stale_ptr{ptr};
    auto ret = set.erase(stale_ptr);
    stale_ptr.release();
    return ret;
}

(live demo)

---

This version, however, is not exception safe in general, because release will not be called if set.erase throws an exception. This is not a problem in this case, since std::equal_to<std::unique_ptr<T>>::operator() never throws exception. In the general case, we can abuse unique_ptr (!) to enforce exception safety by ensuring that release is called regardless of whether the function is exited normally or exceptionally:

template <typename T>
auto erase(std::unordered_set<std::unique_ptr<T>>& set, T* ptr)
{
    std::unique_ptr<T> stale_ptr{ptr};

    auto release = [](std::unique_ptr<T>* p) { p->release(); };
    std::unique_ptr<std::unique_ptr<T>, decltype(release)> release_helper{&stale_ptr, release};

    return set.erase(stale_ptr);
}

(live demo)