Can placement new for arrays be used in a portable way?

Question

Is it possible to actually make use of placement new in portable code when using it for arrays?

It appears that the pointer you get back from new[] is not always the same as the address you pass in (5.3.4, note 12 in the standard seems to confirm that this is correct), but I don't see how you can allocate a buffer for the array to go in if this is the case.

The following example shows the problem. Compiled with Visual Studio, this example results in memory corruption:

#include <new> #include <stdio.h>  class A {     public:      A() : data(0) {}     virtual ~A() {}     int data; };  int main() {     const int NUMELEMENTS=20;      char *pBuffer = new char[NUMELEMENTS*sizeof(A)];     A *pA = new(pBuffer) A[NUMELEMENTS];      // With VC++, pA will be four bytes higher than pBuffer     printf("Buffer address: %x, Array address: %x\n", pBuffer, pA);      // Debug runtime will assert here due to heap corruption     delete[] pBuffer;      return 0; } 

Looking at the memory, the compiler seems to be using the first four bytes of the buffer to store a count of the number of items in it. This means that because the buffer is only sizeof(A)*NUMELEMENTS big, the last element in the array is written into unallocated heap.

So the question is can you find out how much additional overhead your implementation wants in order to use placement new[] safely? Ideally, I need a technique that's portable between different compilers. Note that, at least in VC's case, the overhead seems to differ for different classes. For instance, if I remove the virtual destructor in the example, the address returned from new[] is the same as the address I pass in.

Answer 1

Personally I'd go with the option of not using placement new on the array and instead use placement new on each item in the array individually. For example:

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; } 

Regardless of the method you use, make sure you manually destroy each of those items in the array before you delete pBuffer, as you could end up with leaks ;)

Note: I haven't compiled this, but I think it should work (I'm on a machine that doesn't have a C++ compiler installed). It still indicates the point :) Hope it helps in some way!

---

Edit:

The reason it needs to keep track of the number of elements is so that it can iterate through them when you call delete on the array and make sure the destructors are called on each of the objects. If it doesn't know how many there are it wouldn't be able to do this.

Answer 2

@Derek

5.3.4, section 12 talks about the array allocation overhead and, unless I'm misreading it, it seems to suggest to me that it is valid for the compiler to add it on placement new as well:

This overhead may be applied in all array new-expressions, including those referencing the library function operator new[](std::size_t, void*) and other placement allocation functions. The amount of overhead may vary from one invocation of new to another.

That said, I think VC was the only compiler that gave me trouble with this, out of it, GCC, Codewarrior and ProDG. I'd have to check again to be sure, though.