What is the right way to allocate memory in the C++ constructor?

Question

Which is the right way to allocate memory via new in the C++ constructor. First way in the argument list:

class Boda {
    int *memory;
    public:
        Boda(int length) : memory(new int [length]) {}
        ~Boda() { delete [] memory; }
};

or in the body of constructor:

class Boda {
    int *memory;
    public:
        Boda(int length) {
            memory = new int [length];
        }
        ~Boda() { delete [] memory; }
};

Thanks, Boda Cydo.

Answer 1

If you want to catch memory allocation errors (which you probably should) then you'll have to make the call to new in the body of the constructor.

Answer 2

I would say both are equivalent in the effect they produce and both are "the right way". I prefer initializer lists but I would go with the second variant just to be able to test for invalid length argument before trying to allocate the memory.

Answer 3

The problem is more general. See C++ FAQ Lite: [10.6] Should my constructors use "initialization lists" or "assignment"?

Answer 4

You should use resource management classes that will handle it for you. Else, you run into some serious problems with exception safety, aside from needlessly duplicating existing logic and maintenance of copy/assignment operators.

Answer 5

I think the simplest way to do this would be to use a boost scoped array and let someone else's well tested library code handle it all for you.

So:

class Boda {
    boost::scoped_array<int> memory;
    public:
        Boda(int length) : memory(new int [length]) {}
       ~Boda() {}
};

Moreover, scoped arrays cannot be copied - so you avoid the nasty copy constructor deallocation issue mentioned in another answer.

Answer 6

memory member variable is a pointer, if you allocate it in initialization list and it fails, your class is not initialized and you don't need to free it later (thanks to RAII design pattern which is used by C++ for class initialization). If you allocate its memory inside the constructor's body, similar behavior will happens.

But if you want to handle something, then allocate its memory in the constructor's body. Check something or try/catch it or print some useful messages, but at least, you have to throw another exception, because your class initialization is broken.

I think memory allocation in the constructor's body is more readable than the other one.