问题
I am storing the ownership of some objects inside an unordered_set
, using unique_ptr
s.
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 theunique_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)
回答1:
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)
回答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);
}
}
来源:https://stackoverflow.com/questions/60220220/efficiently-erase-a-unique-ptr-from-an-unordered-set