使用索引避免迭代器失效，维护干净的接口

Question

我创建了一个MemoryManager<T> 类，它基本上是两个指针向量的包装器，用于管理堆分配对象的生命周期。

一个向量存储“活动”对象，另一个存储将在下一个MemoryManager<T>::refresh 添加的对象。

选择这种设计是为了避免在循环MemoryManager<T> 时使迭代器失效，因为直接向MemoryManager<T>::alive 向量添加新对象会使现有迭代器失效（如果它的大小增加）。

template<typename T> struct MemoryManager {
    std::vector<std::unique_ptr<T>> alive;
    std::vector<T*> toAdd;

    T& create() { 
        auto r(new T); 
        toAdd.push_back(r); 
        return *r; 
    }

    T& refresh() { 
         // Use erase-remove idiom on dead objects
         eraseRemoveIf(alive, [](const std::unique_ptr<T>& p){ return p->alive; });

         // Add all "toAdd" objects and clear the "toAdd" vector
         for(auto i : toAdd) alive.emplace_back(i); 
         toAdd.clear(); 
    }  

    void kill(T& mItem)  { mItem.alive = false; }

    IteratorType begin() { return alive.begin(); }
    IteratorType end()   { return alive.end(); }
}

我在我的游戏引擎中使用它来存储实体，并在每一帧更新每个“活着”的实体：

void game() {
    MemoryManager<Entity> mm;

    while(gameLoop) {
        mm.refresh();
        for(auto e : mm) processEntity(e);
        auto& newEntity = mm.create();
        // do something with newEntity
    }
}

这让我可以不断地创建/杀死实体，而不必过多担心它们的生命周期。

---

但是，我最近得出的结论是，没有必要使用两个 std::vector。我可以简单地使用单个向量并将迭代器存储到“最后一个存活对象”，在上述迭代器之后立即添加新创建的对象：

在我看来，这个想法很好用……但我实际上不能为 end 使用迭代器类型（如图所示），因为在向向量添加一些新元素后它可能会失效.我已经测试过了，这种情况经常发生，导致崩溃。

我能想到的另一个解决方案是使用索引而不是迭代器。这将解决崩溃问题，但我无法使用酷炫的 C++11 for(x : y) foreach 循环，因为 MemoryManager<T>::begin 和 MemoryManager<T>::end 需要返回一个迭代器。

有没有办法用单个向量实现当前行为，并且仍然保持清晰的接口，可以与 C++11 for-each 循环一起使用？

Answer 1

获得稳定的迭代器（和引用）的最简单方法之一是使用std::list<T>。除非您需要 T 作为指向多态基类的指针，否则最好使用 std::list<T>，而不是 std::list<std::unique_ptr<T>>。

另一方面，如果您的Entity 是多态基，则考虑使用std::vector<std::unique_ptr<T>>。尽管您不能依赖迭代器保持有效，但您可以依赖指针和对 Entity 的引用通过 std::vector<std::unique_ptr<T>> 保持有效。

在您的game() 示例中，您永远不会利用稳定的迭代器或指针。您也可以轻松（更简单）地这样做：

void game() {
    std::vector<Entity> mm;

    while(gameLoop) {
        mm.erase(std::remove_if(mm.begin(), mm.end(), [](const Entity& e)
                                                      { return e.alive; }),
                                                      mm.end());
        for(auto e : mm) processEntity(e);
        mm.push_back(create());
        auto& newEntity = mm.back();
        // do something with newEntity
    }
}

在processEntity 循环期间，无法使迭代器无效。如果你这样做了，你最好不要使用基于范围的 for，因为结束迭代器只在循环开始时计算一次。

但是，如果您确实需要稳定的迭代器/引用，替换 std::list<Entity> 将非常容易。我会将erase/remove 改为使用list 的成员remove_if。效率会更高。

如果您这样做，和性能测试（不是猜测）表明您的现有 MemoryManager 的性能受到影响，您可以使用“堆栈分配器”优化 list比如这里演示的：

http://howardhinnant.github.io/stack_alloc.html

这允许您预先分配空间（可以在堆栈上，也可以在堆上），并让您的容器从中分配。在预先分配的空间用尽之前，这将是高性能和缓存友好的。而且您仍然拥有迭代器/指针/引用的稳定性。

总结：

1. 找出/告诉我们unique_ptr<Entity> 是否真的必要，因为Entity 是一个基类。首选container<Entity> 而不是container<unique_ptr<Entity>>。

2. 您真的需要迭代器/指针/引用稳定性吗？您的示例代码没有。如果您实际上不需要它，请不要为此付费。使用vector<Entity>（或vector<unique_ptr<Entity>>，如果必须）。

3. 如果你真的需要container<unique_ptr<Entity>>，你能在牺牲迭代器稳定性的同时摆脱指针/引用的稳定性吗？如果是，vector<unique_ptr<Entity>> 是最好的选择。

4. 如果您确实需要迭代器稳定性，强烈考虑使用std::list。

5. 如果您使用 std::list 并通过测试发现它存在性能问题，请使用适合您需求的分配器对其进行优化。

6. 如果以上都失败了，那么开始设计你自己的数据结构。如果您走到这一步，请知道这是最困难的路线，并且一切都需要通过正确性和性能测试来支持。

Answer 2

您可以实现自己的迭代器类。

以下内容可能会有所帮助。

template <typename T, typename... Ts>
class IndexIterator : public std::iterator<std::random_access_iterator_tag, T>
{
public:
    IndexIterator(std::vector<T, Ts...>& v, std::size_t index) : v(&v), index(index) {}

    // if needed.
    typename std::vector<T, Ts...>::iterator getRegularIterator() const { return v->begin() + index; }

    T& operator *() const { return v->at(index); }
    T* operator ->() const { return &v->at(index); }

    IndexIterator& operator ++() { ++index; return *this;}
    IndexIterator& operator ++(int) { IndexIterator old(*this); ++*this; return old;}
    IndexIterator& operator +=(std::ptrdiff_t offset) { index += offset; return *this;}
    IndexIterator operator +(std::ptrdiff_t offset) const { IndexIterator res (*this); res += offset; return res;}

    IndexIterator& operator --() { --index; return *this;}
    IndexIterator& operator --(int) { IndexIterator old(*this); --*this; return old;}
    IndexIterator& operator -=(std::ptrdiff_t offset) { index -= offset; return *this;}
    IndexIterator operator -(std::ptrdiff_t offset) const { IndexIterator res (*this); res -= offset; return res;}

    std::ptrdiff_t operator -(const IndexIterator& rhs) const { assert(v == rhs.v); return index - rhs.index; }

    bool operator == (const IndexIterator& rhs) const { assert(v == rhs.v); return index == rhs.index; }
    bool operator != (const IndexIterator& rhs) const { return !(*this == rhs); }

private:
    std::vector<T, Ts...>* v;
    std::size_t index;
};

template <typename T, typename... Ts>
IndexIterator<T, Ts...> IndexIteratorBegin(std::vector<T, Ts...>& v)
{
    return IndexIterator<T, Ts...>(v, 0);
}

template <typename T, typename... Ts>
IndexIterator<T, Ts...> IndexIteratorEnd(std::vector<T, Ts...>& v)
{
    return IndexIterator<T, Ts...>(v, v.size());
}

Answer 3

您可以通过维护一个空闲列表来避免移动容器的元素（请参阅http://www.memorymanagement.org/glossary/f.html#free.list）。

为避免对元素的引用无效，如果您不在中间插入或擦除，则可以使用 std::deque。 为避免迭代器失效，您可以使用 std::list。

（感谢霍华德·欣南特）

Answer 4

您可以实现自己的迭代器类，以您喜欢的方式处理事情。然后您的 begin() 和 end() 可以返回该类的实例。例如，您的自定义迭代器可以存储整数索引和指向向量本身的指针，从而使迭代器即使在重新分配时也保持有效。