Можно ли использовать новое размещение для массивов переносным способом?

Лично я бы предпочел не использовать placement new в массиве, а вместо этого использовать placement new для каждого элемента в массиве по отдельности. Например:

int main(int argc, char* argv[])
{
  const int NUMELEMENTS=20;

  char *pBuffer = new char[NUMELEMENTS*sizeof(A)];
  A *pA = (A*)pBuffer;

  for(int i = 0; i < NUMELEMENTS; ++i)
  {
    pA[i] = new (pA + i) A();
  }

  printf("Buffer address: %x, Array address: %x\n", pBuffer, pA);

  // dont forget to destroy!
  for(int i = 0; i < NUMELEMENTS; ++i)
  {
    pA[i].~A();
  }    

  delete[] pBuffer;

  return 0;
}

Независимо от используемого метода, убедитесь, что вы вручную уничтожили каждый из этих элементов в массиве, прежде чем удалить pBuffer, так как это может привести к утечке данных ;)

Примечание: Я не компилировал это, но я думаю, что это должно работать (я нахожусь на машине, на которой не установлен компилятор C++). Это все еще указывает на точку :) надеюсь, что это поможет в некотором роде!

Редактировать:

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

@Derek

5.3.4, раздел 12 говорит о накладных расходах на выделение массива, и, если я не ошибаюсь, мне кажется, что компилятор может добавить его также и при новом размещении:

Эти накладные расходы могут быть применены во всех выражениях массива new-expressions, включая те, которые ссылаются на оператор библиотечной функции new[](std::size_t, void*) и другие функции распределения размещения. Объем накладных расходов может варьироваться от одного вызова new к другому.

Тем не менее, я думаю, что VC был единственным компилятором, который дал мне проблемы с этим, из него, GCC, Codewarrior и ProDG. Хотя мне придется проверить еще раз, чтобы убедиться в этом.

Спасибо за ответы. Использование размещения new для каждого элемента в массиве было решением, которое я использовал, когда столкнулся с этим (извините, я должен был упомянуть об этом в вопросе). Я просто чувствовал, что, должно быть, что-то упустил, делая это с размещением new[]. Как бы то ни было, похоже, что placement new[] по существу непригоден для использования благодаря стандарту, позволяющему компилятору добавлять дополнительные неопределенные накладные расходы к массиву. Я не понимаю, как вы могли бы использовать его безопасно и переносимо.

Я даже не совсем понимаю, зачем ему нужны дополнительные данные, поскольку вы все равно не вызовете delete[] в массиве, поэтому я не совсем понимаю, зачем ему нужно знать, сколько элементов в нем находится.

@James

Я даже не совсем понимаю, зачем ему нужны дополнительные данные, поскольку вы все равно не вызовете delete[] в массиве, поэтому я не совсем понимаю, зачем ему нужно знать, сколько элементов в нем находится.

Поразмыслив немного, я соглашусь с вами. Нет никакой причины, по которой placement new должен хранить количество элементов, потому что нет никакого placement delete. Так как там нет размещения delete, нет никакой причины для размещения new, чтобы сохранить количество элементов.

Я также протестировал это с gcc на моем Mac, используя класс с деструктором. В моей системе размещение нового не изменяло указатель. Это заставляет меня задуматься, является ли это проблемой VC++, и может ли это нарушить Стандарт (Стандарт специально не рассматривает это, насколько я могу найти).

Само по себе размещение new является переносимым, но предположения, которые вы делаете о том, что оно делает с определенным блоком памяти, не являются переносимыми. Как было сказано ранее, если бы Вы были компилятором и вам дали кусок памяти, как бы вы знали, как выделить массив и правильно уничтожить каждый элемент, если бы у вас был только указатель? (См. интерфейс оператора delete[].)

Редактировать:

И там на самом деле есть placement delete, только он вызывается только тогда, когда конструктор создает исключение при выделении массива с placement new[].

Действительно ли new[] нужно каким-то образом отслеживать количество элементов-это то, что остается до стандарта, который оставляет это на усмотрение компилятора. К сожалению, в данном случае.

Я думаю, что gcc делает то же самое, что и MSVC, но, конечно, это не делает его "portable".

Я думаю, что вы можете обойти эту проблему, когда NUMELEMENTS действительно является постоянной времени компиляции, например:

typedef A Arr[NUMELEMENTS];

A* p = new (buffer) Arr;

Аналогично тому, как вы использовали бы один элемент для вычисления размера для одного размещения-new, используйте массив этих элементов для вычисления размера, необходимого для массива.

Если вам требуется размер для других вычислений, где количество элементов может быть неизвестно, Вы можете использовать sizeof (A[1]) и умножить его на необходимое количество элементов.

е.г

char *pBuffer = new char[ sizeof(A[NUMELEMENTS]) ];
A *pA = (A*)pBuffer;

for(int i = 0; i < NUMELEMENTS; ++i)
{
    pA[i] = new (pA + i) A();
}