关于向量中重复的 unique_ptr 项的所有权错误答案

【问题标题】：Ownership mistake about duplicated unique_ptr items in a vector关于向量中重复的 unique_ptr 项的所有权错误
【发布时间】：2019-09-11 22:30:21
【问题描述】：

考虑到以下代码，我该如何解决我面临的所有权问题？

我需要在不复制Item 的情况下处理这种情况，因为我做不到。

Item 和 ItemContainer 是 API 的一部分，用户不应该担心重复，这意味着如果用户为同一个指针调用两次，我需要静默添加指针两次。

我以为我的删除器会解决它，但它没有。

例如，我不能使用unordered_set，我应该像现在这样处理这种情况。

ItemContainer.h：

typedef std::unique_ptr<Item, std::function<void(Item *)>> ItemDeleter;
std::vector<ItemDeleter> items_;

ItemContainer.cpp：

void ItemContainer::addItem(Item *item)
{
  ItemDeleter uniqPtrItem(item, [](Item *p) {
    if (p != nullptr) { 
      delete p; //it's crashing here, obviously
      p = nullptr;
    }
  });
  items_.push_back(std::move(uniqPtrTask));
}

main.cpp

int main() {
  Item *item = new Item();
  ItemContainer itemContainer;
  itemContainer.addItem(item);
  itemContainer.addItem(item);
}

【问题讨论】：

如果你想让多个指针指向同一个东西，为什么不直接使用std::shared_ptr？
好一个！这是我范围内的要求。
谁创建了指针？用户将如何在两个不同的场合传递相同的指针？谁破坏了指针？

标签： c++ c++11 smart-pointers stdvector move-semantics

【解决方案1】：

如果您不能使用std::shared_ptr（这是显而易见且最自然的解决方案），那么您可以参考计数您的Items。下面是一些简单的演示代码，展示了如何做到这一点：

#include <vector>
#include <memory>
#include <iostream>

class RefCount
{
public:
    void Retain ()
    {
        ++refcount;
    }

    void Release ()
    {
        if (--refcount == 0)
            delete this;
    }

protected:
    virtual ~RefCount () {}

private:    
    int refcount = 1;
};

class Item : public RefCount
{
public:
    Item () { std::cout << "Item constructor\n"; }
private:
    ~Item () { std::cout << "Item destructor\n"; }
};

typedef std::unique_ptr <Item, void (*) (Item *)> ItemDeleter;

void addItem (std::vector <ItemDeleter> &items, Item *item)
{
    item->Retain ();
    ItemDeleter uniqPtrItem (item, [] (Item *p) { p->Release (); });
    items.push_back (std::move (uniqPtrItem));
}

int main()
{
    std::vector <ItemDeleter> items;
    Item *item = new Item;
    addItem (items, item);
    addItem (items, item);
    item->Release ();
}

输出：

Item constructor
Item destructor

Live demo

【讨论】：

【解决方案2】：

鉴于您的情况所造成的限制，这就是我要解决的方法。

如果他们将原始指针传递到容器中，使用 shared_ptr 将不起作用，因为您仍然需要检查指针是否包含在容器中的其他任何位置。这同样适用于unique_ptr - 您必须检查它是否出现在容器中的其他任何地方。

没有办法解决：您必须检查容器是否已经有该项目。话虽如此，我们可以使用unordered_map 有效地做到这一点。该地图将跟踪每个项目在容器中出现的次数，当一个项目不再出现在容器中时，删除它是安全的。

template<class Item>
class ItemContainer {
    std::unordered_map<Item*, int> item_counts;
    std::vector<Item*> items; 
   public:
    ItemContainer() = default;
    ItemContainer(ItemContainer&&) = default;
    ItemContainer(ItemContainer const&) = default; 

    void addItem(Item* item) {
        item_counts[item] += 1;
        items.push_back(item); 
    }
    void removeTopItem() {
        // Get the top item and remove it from the vector
        auto item = items.back(); 
        items.pop_back(); 
        // Find the number of times the item appears in the vector
        auto iter = item_counts.find(item);
        auto& count = iter->second;

        if(count == 1) {
            // If it appeared only once, erase it from the map and delete the item
            item_counts.erase(iter); 
            delete item; 
        } else {
            // Otherwise, just update the count
            count -= 1;
        }
    }
    ~ItemContainer() {
        for(auto& count : item_counts) {
            auto item = count.first;
            delete item; 
        }
    }
};

【讨论】：