Question

我一直在寻找能够最好地处理这种情况的容器：

线性记忆（没有像对象池或分配器那样的间隙）
某种方式可以引用容器中的对象，该对象在添加/删除之间保持不变。或者是一种快速搜索以查找原始对象的方法。
从中间加快结束和删除（但不需要插入）

到目前为止，我能找到的唯一解决方案是使用std::vector，当发生删除时，我会更新当前正在删除的索引之上的所有引用索引。这看起来很糟糕，寻找任何其他更高效的解决方案。

Answer 1

这是一个可怕的想法。我根本没有尝试过，所以可能存在不止一些错误。

  template <typename T>
  class InsaneContainter {
  public:
     class MemberPointer {
        friend class InsaneContainer;
        size_t idx_;
        InsaneContainter* parent_;
     public:
        MemberPointer(InsaneContainter* parent,size_t idx) idx_(idx),parent_(parent){}
        T& operator*() {
           parent->members[idx_];
        }
     };
     friend class MemberPointer;
     using Handle = std::shared_ptr<MemberPointer>;
     Handle insert(const T& t) {
        members.push_back(std::make_tuple(T{t},Handle{new MemberPointer{this,members.size()}));
        return std::get<1>(members.back());
     }
     Handle GetHandle(size_t idx) {
       return std::get<1>(members[idx]);
     }
     void delete(size_t idx) {
         //swap with end
         std::swap(members[idx],members.back());
         std::get<1>(members[idx])->idx_=idx;
         members.pop_back();
     }
private:
     std::vector<std::tuple<T,std::shared_ptr<MemberPointer>> members_;
};

这个想法是，在插入时，你会收到一个总是有O（1）查找和删除的句柄。虽然找到对象是另外的O（n），但一旦找到它，你就可以获得最新的句柄。

这种结构的使用是......限于至少我怀疑和X与Y问题在这里。

Answer 2

通过大量的性能测试，我找到了下面一般情况下最快的方法：

1。）使用存储空闲区域的池分配器。

2.使用空闲内存区域列表将占用数据线性复制到池中每个“间隙”的临时内存中。

由于我的程序中添加/删除的性质（导致碎片很少），这对我来说效果最好

具有持久查找的线性内存容器？

2 个答案: