How to dynamically allocate array of objects using parameterized constructor? [duplicate]

Question

Consider a simple class:

class SimpleClass {
    int a;
public:
    SimpleClass():a(0){}
    SimpleClass(int n):a(n){}
    // other functions
};

SimpleClass *p1, *p2;

p1 = new SimpleClass[5];

p2 = new SimpleClass(3);

In this case the default constructor SimpleClass() gets called for the construction of newly allocated objects for p1 and the parameterized constructor for p2. My question is: Is it possible to allocate an array and use the parameterized constructor using the new operator? For example, if I want the array to be initialized with objects having variable a value being 10, 12, 15, ... respectively, is it possible to pass these values when using the new operator?

I know that using stl vector is a better idea to deal with arrays of objects. I want to know whether the above is possible using new to allocate an array.

Answer 1

You could use placement-new as:

typedef std::aligned_storage<sizeof(SimpleClass), 
                             std::alignment_of<SimpleClass>::value
                             >::type storage_type;

//first get the aligned uninitialized memory!
SimpleClass *p1 = reinterpret_cast<SimpleClass*>(new storage_type[N]);

//then use placement new to construct the objects
for(size_t i = 0; i < N ; i++)
     new (p1+i) SimpleClass(i * 10);

In this example, I'm passing (i * 10) to the constructor of SampleClass.

• Online Demo

Hope that helps.

Answer 2

This is one way but it's not exactly what you achieve by new SimpleClass[5] because it creates an array of pointers instead of an array of values:

SimpleClass *p[] = {
    new SimpleClass(10), 
    new SimpleClass(12), 
    new SimpleClass(15)
};

To achieve what you want, I'd recommend code similar to this:

SimpleClass *p2 = new SimpleClass[3];
SimpleClass *pp = p2;
*pp = 10;
*++pp = 12;
*++pp = 15;

It's not ideal because it will create temporary objects on the stack and call assignment operator but it looks clean from the code perspective. Performance is sacrificed here a little bit.