стратегия выделить/освободить много маленьких объектов

Если вы можете заранее предсказать размер выделенного объекта, вы, вероятно, будете лучше чтобы использовать линейно выделенный кусок памяти и свой собственный распределитель (как предложил @Kerido). К этому я бы добавил, что наиболее эффективным методом было бы обнуление и замена позиций в распределении, и не беспокоиться о повторном разбиении и уплотнении массива (оставлять мертвое пространство между распределениями), поэтому вам не нужно иметь дело с обновлениями индекса и индексом техническое обслуживание.

Если вы можете разделить свои объекты заранее (т.е. вы знаете, что у вас есть элементы нефиксированного размера, но группа легко), разделите их на сегменты и предварительно выделите фрагменты памяти в каждом сегменте и поменяйте местами элементы в соответствующий сегмент. . Если ваши объекты могут изменять размер в течение своего срока службы, управлять этим может быть непросто, поэтому внимательно рассмотрите этот подход.

Если вы знаете максимальный размер ваших массивов, вы можете использовать собственный распределитель. Вам придется написать класс распределителя самостоятельно. Он должен сразу выделить большой кусок памяти и преобразовать его в связанный список. Каждый раз, когда необходимо создать экземпляр объекта, вы удаляете хвост из списка. Каждый раз, когда объект нужно освободить, вы добавляете запись в список.

РЕДАКТИРОВАТЬ: вот образец из Бьярна Страуструпа Язык программирования C ++, 3-е издание :

class Pool
{
private:
  struct Link
    { Link * next; };

  struct Chunk
  {
    enum {size = 8*1024-16};

    Chunk * next;
    char mem[size];
  };

private:
  Chunk * chunks;
  const unsigned int esize;
  Link * head;

private:
  Pool (const Pool &) { }      // copy protection
  void operator = (Pool &) { } // copy protection

public:
  // sz is the size of elements
  Pool(unsigned int sz)
    : esize(sz < sizeof(Link*) ? sizeof(Link*) : sz),
      head(0), chunks(0)
    { }

  ~Pool()
  {
    Chunk * n = chunks;

    while(n)
    {
      Chunk * p = n;
      n = n->next;
      delete p;
    }
  }


public:

  // allocate one element
  void * alloc()
  {
    if(head == 0)
      grow();

    Link * p = head;
    head = p->next;

    return p;
  }

  // put an element back into the pool
  void free(void * b)
  {
    Link * p = static_cast<Link*>(b);
    p->next = head; //put b back as first element
    head = p;
  }

private:
  // make pool larger
  void grow()
  {
    Chunk* n = new Chunk;
    n->next = chunks;
    chunks = n;

    const int nelem = Chunk::size / esize;
    char * start = n->mem;
    char * last = &start [ (nelem - 1) * esize ];

    for(char * p = start; p < last; p += esize) // assume sizeof(Link) <= esize
      reinterpret_cast<Link>(p)->next = reinterpret_cast<Link *>(p + esize);

    reinterpret_cast<Link *>(last)->next = 0;
    head = reinterpret_cast<Link *>(start);
  }
};