Question

I’d like to be able to “somehow” create a dynamic array that would still let me build its elements using the new operator.
Here’s what I’d like to achieve:

A* a = new A[3]; //or any equivalent syntax 
new (&a[0]) A(myparams1); //placement new on first slot 
new (&a[1]) A(myparams2, ...); //placement new on 2nd slot 
new (&a[2]) A(myparams3, ...); //placement new on 3rd slot
delete[] a; //correct deletion of all elements

I’m aware that this code would work (minus the 3 elements overwritten), but I’d like to avoid creating 3 default a elements in the first call to new[]. I am assuming here that I will always place 3 elements before calling delete[].
I’m thinking such a thing can be achieved by using intelligent calls to A::operator new[] but I’m not sure how.
Does anyone have any idea? it’s mostly for curiosity

Answer 1

You just get raw memory instead:

void* mem = ::operator new(capacity * sizeof(A));

This is required to be aligned for any type, including an array of A‘s. Now you can construct in it:

for (std::size_t i = 0; i < capacity; ++i)
{
    void* addr = static_cast<char*>(mem) + i * sizeof(A);
    new (addr) A(x, y, z, ...);
}

Destruction requires you explicitly invoke it:

for (std::size_t i = 0; i < capacity; ++i)
{
    void* addr = static_cast<char*>(mem) + i * sizeof(A);
    static_cast<A*>(addr)->~A();
}

And now you can free the raw memory:

::operator delete(mem);

Note that none of this is exception-safe. It’s also what std::vector<A> does, check out the code.