Question

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

因为我做不到，所以我需要不复制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);
}

Answer 1

如果您不能使用std::shared_ptr（这是显而易见的也是最自然的解决方案），则可以引用计数Item。这是一些简单的演示代码，展示了如何做到这一点：

#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

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

向量中重复的unique_ptr项重复的所有权错误

2 个答案: