有点像Kylotan的建议，但我建议尽可能在数据结构级别解决此问题，如果可以的话，不要在较低的分配程序级别解决。
这是一个简单的示例，说明如何避免Foos使用带有将元素链接在一起的孔的数组重复分配和释放（在“容器”级别而不是“分配器”级别解决）：
struct FooNode
{
explicit FooNode(const Foo& ielement): element(ielement), next(-1) {}
// Stores a 'Foo'.
Foo element;
// Points to the next foo available; either the
// next used foo or the next deleted foo. Can
// use SoA and hoist this out if Foo doesn't
// have 32-bit alignment.
int next;
};
struct Foos
{
// Stores all the Foo nodes.
vector<FooNode> nodes;
// Points to the first used node.
int first_node;
// Points to the first free node.
int free_node;
Foos(): first_node(-1), free_node(-1)
{
}
const FooNode& operator[](int n) const
{
return data[n];
}
void insert(const Foo& element)
{
int index = free_node;
if (index != -1)
{
// If there's a free node available,
// pop it from the free list, overwrite it,
// and push it to the used list.
free_node = data[index].next;
data[index].next = first_node;
data[index].element = element;
first_node = index;
}
else
{
// If there's no free node available, add a
// new node and push it to the used list.
FooNode new_node(element);
new_node.next = first_node;
first_node = data.size() - 1;
data.push_back(new_node);
}
}
void erase(int n)
{
// If the node being removed is the first used
// node, pop it from the used list.
if (first_node == n)
first_node = data[n].next;
// Push the node to the free list.
data[n].next = free_node;
free_node = n;
}
};
达到这种效果的原因：带有空闲列表的单链接索引列表。索引链接使您可以跳过已删除的元素，在固定时间内删除元素，还可以通过固定时间插入来回收/重用/覆盖空闲元素。要遍历结构，您可以执行以下操作：
for (int index = foos.first_node; index != -1; index = foos[index].next)
// do something with foos[index]
而且，您可以使用模板，放置新的和手动dtor调用来通用化上述类型的“孔的链接数组”数据结构，从而避免进行复制分配，在删除元素时调用析构函数，提供正向迭代器等。选择使示例非常类似于C，以更清楚地说明概念，也因为我很懒。
就是说，在您从中间移除很多东西并将其插入中间后，此结构的空间局部性确实会下降。到那时，next链接可能会让您沿着向量来回走动，以相同的顺序遍历重新加载先前从高速缓存行中驱出的数据（这对于任何允许在回收时不删除元素的情况下进行恒定时间删除的数据结构或分配器都是不可避免的从中间插入空格，并进行恒定时间插入，而不使用并行位集或removed标志之类的东西）。为了恢复缓存友好性，您可以实现一个复制ctor和swap方法，如下所示：
Foos(const Foos& other)
{
for (int index = other.first_node; index != -1; index = other[index].next)
insert(foos[index].element);
}
void Foos::swap(Foos& other)
{
nodes.swap(other.nodes):
std::swap(first_node, other.first_node);
std::swap(free_node, other.free_node);
}
// ... then just copy and swap:
Foos(foos).swap(foos);
现在，新版本再次对缓存友好，可以遍历。另一种方法是将索引的单独列表存储到结构中，并定期对其进行排序。另一个是使用位集来指示使用了哪些索引。这样一来，您始终可以按顺序遍历位集（要高效地执行此操作，请一次检查64位，例如使用FFS / FFZ）。该位集是最高效且非侵入性的，每个元素仅需要一个并行位即可指示使用了哪些元素，哪些元素被删除了，而不需要32位next索引，但是写得最好的时间最多（不会如果您一次检查一位就可以快速遍历-您需要FFS / FFZ一次一次在32个以上的位中立即找到一个设置或未设置的位，以快速确定占用索引的范围）。
通常，此链接解决方案最容易实现，并且是非侵入式的（不需要修改Foo即可存储一些removed标志），如果您不希望32位数据泛化到任何数据类型，则可以使用此链接解决方案每个元素的开销。
我应该为动态分配创建任何内存池，还是不必为此烦恼？如果目标平台是移动设备怎么办？
需求是一个强有力的词，我偏向于在性能至关重要的领域（例如光线跟踪，图像处理，粒子模拟和网格处理）中工作，但是分配和释放用于非常轻便的处理（如子弹头）的微小对象相对非常昂贵和粒子分别针对通用的可变大小的内存分配器。鉴于您应该能够在一两天内概括上述数据结构以存储所需的任何内容，我认为这是值得进行的交易，以消除为每笔小小的事情而直接支付的此类堆分配/重新分配成本。除了减少分配/重新分配成本之外，您还可以更好地遍历引用遍历结果的位置（即更少的缓存未命中和页面错误）。
至于乔什提到的关于GC的内容，我没有像Java一样仔细研究C＃的GC实现，但是GC分配器通常具有初始分配这非常快，因为它使用的是顺序分配器，该分配器无法从中间释放内存（几乎像堆栈一样，您不能从中间删除内容）。然后，它付出了昂贵的成本，实际上是通过复制内存并清除以前分配的内存作为整体，从而允许在单独的线程中删除单个对象（例如一次破坏整个堆栈，而将数据复制到更类似链接结构的对象中），但是由于它是在单独的线程中完成的，因此它不一定会使应用程序的线程停滞不前。但是，这会带来非常高的隐性成本，即需要额外的间接级别，并且在初始GC周期后会丢失LOR。但是，这是加快分配速度的另一种策略-使它在调用线程中更便宜，然后在另一个线程中完成昂贵的工作。为此，您需要两个级别的间接引用来引用您的对象，而不是一个，因为在您最初分配的时间和第一个周期之后，它们最终将在内存中被拖曳。
同样，在C ++中更容易应用的另一种策略是，不必费心在主线程中释放对象。只是不断增加数据结构的末尾，不允许从中间删除东西。但是，标记那些需要删除的东西。然后，一个单独的线程可以处理创建新数据结构而无需删除元素的昂贵工作，然后以原子方式将新的数据结构与旧的交换，例如，分配和释放元素的大部分成本都可以传递给如果您可以假设不必立即满足删除元素的要求，则可以使用单独的线程。这不仅使就线程而言释放更便宜，而且使分配更便宜，因为您可以使用更简单，更笨拙的数据结构，而不必处理中间的删除案例。就像一个容器，只需要一个push_back用于插入的clear功能，用于删除所有元素并swap与新的紧凑型容器交换内容的功能（不包括已删除的元素）；就变异而言，仅此而已。