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

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

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 для массива, и убедитесь, что деструкторы вызваны для каждого из объектов. Если он не знает, сколько их, он не сможет этого сделать.

Я думаю, что gcc делает то же самое, что и MSVC, но, конечно, это не делает его «переносимым».

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

typedef A Arr[NUMELEMENTS];

A* p = new (buffer) Arr;

Это должно использовать скалярное размещение нового.

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

Если вам требуется размер для других вычислений, где число элементов может быть неизвестно, вы можете использовать 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();
}

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

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

@Джеймс

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

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

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

@Derek

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

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

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

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

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

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

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