如何通过指针从容器中删除 unique_ptr？

Question

使用 unique_ptr 创建对象并赋予容器所有权是没有问题的。如何通过原始指针删除元素？

std::set<std::unique_ptr<MyClass>> mySet;

MyClass *myClass = new MyClass();
mySet.insert(std::unique_ptr<MyClass>(myClass));

// remove myClass from mySet?

Answer 1

您需要找到与 myClass 元素对应的迭代器，然后将该迭代器传递给 mySet.erase()。可以使用 std::find_if 算法和自定义 Predicate 函子来找到迭代器，该函子了解如何取消引用 unique_ptr 并将其与原始值进行比较指针myClass。

您不能使用重载的 size_t set::erase ( const key_type& x );，因为在以下位置找不到原始指针（即使包装在临时 unique_ptr 中） mySet。

Answer 2

没有我想要的那么漂亮。但以下内容可以完成这项工作：

#include <memory>
#include <set>
#include <iostream>

struct do_nothing
{
    void operator()(const void*) const {}
};

struct MyClass
{
    MyClass() {std::cout << "MyClass()\n";}
    MyClass(const MyClass&) {std::cout << "MyClass(const MyClass&)\n";}
    ~MyClass() {std::cout << "~MyClass()\n";}
};

int main()
{
    std::set<std::unique_ptr<MyClass>> mySet;

    MyClass *myClass = new MyClass();
    mySet.insert(std::unique_ptr<MyClass>(myClass));

    // remove myClass from mySet?
    std::set<std::unique_ptr<MyClass>>::iterator i =
        lower_bound(mySet.begin(), mySet.end(),
                    std::unique_ptr<MyClass, do_nothing>(myClass));
    if (i != mySet.end() && *i == std::unique_ptr<MyClass, do_nothing>(myClass))
        mySet.erase(i);
}

Answer 3

看来我能够使用带有 lower_bound 的自定义谓词来检索迭代器。由于 std::set 是一个有序容器，因此 lower_bound 应该以对数方式执行。

std::set<std::unique_ptr<MyClass>>::iterator i =
    std::lower_bound(mySet.begin(), mySet.end(), myClass, MyPredicate<MyClass>());

template<class Type>
struct MyPredicate
{
    bool operator()(const std::unique_ptr<Type>& left, const Type* right) const
    {
        return left.get() < right;
    }
}

Answer 4

仍然不是最好的解决方案，但目前我选择：

PointerMap<MyFoo>::Type myFoos;

MyFoo * myFoo = new MyFoo();
myFoos.insert(PointerMap<MyFoo>::Item(myFoo));

标题是：

#include <map>
#include <memory>
#include <utility>

template<typename T>
struct PointerMap
{
    typedef std::map<T *, std::unique_ptr<T>> Type;

    struct Item : std::pair<T *, std::unique_ptr<T>>
    {
        Item(T * pointer)
            : std::pair<T *, std::unique_ptr<T>>(pointer, std::unique_ptr<T>(pointer))
        {
        }
    };
};

Answer 5

您可能喜欢这里的答案：有效擦除a unique_ptr from an unordered_set

这适用于 C++14，但我认为也适用于 C++11。

它并不漂亮，但效率很高——不扫描容器，而是使用适当的基于哈希的查找。

Answer 6

异常安全的解决方案，具有基于哈希的高效查找（因此消除了 std::find_if 或 std::lower_bound 的线性时间复杂度）并且没有透明度限制（这是我对类似问题的回答的副本）：

/*
 * 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();
    }
};

用法：

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});
}

以便您得到

mySet.erase(bad_ptr{myClass});