Leaking in constructor

Question

Do I leak if I allocate memory with new in the constructor of an object and immediately after I throw an exception?

The object shouldn't be constructed at all and thus no destructor will be called, but what about that memory?

e.g.

MyObject() {
  data = new char[200]; // Will this be leaked?

  if(something_is_wrong)
    throw exception();

}

Yes, use something that owns that memory and behaves properly like `std::string`. — chris, Jun 12 '14 at 13:58
What type is `data`? `data` will be destructed so if it is of a type that expects to manage the memory assigned to it there might not be a leak. — CB Bailey, Jun 12 '14 at 13:59
Never acquire a resource that needs manually freeing in a constructor unless the sole purpose of the class is to manage that resource. — JoeG, Jun 12 '14 at 15:16

score 4 · Answer 1 · answered Jun 12 '14 at 13:58

4

It will leak. Once you have gotten a pointer from new it eventually needs to be deleted. The solution is to make data a smart pointer (or in this case, probably a std::string); while MyObject's destructor won't be called, data members' destructors are called.

answered Jun 12 '14 at 13:58

Simple

13,992
2
47
47

1

You don't know if `data` won't cleanup after itself, though, so it's just a guess. It is *possible* for that code to leak memory. – Bartek Banachewicz Jun 12 '14 at 14:08
@BartekBanachewicz I'm assuming `data` is something like `char*` in his example. – Simple Jun 12 '14 at 14:11
Yeah, my point precisely. Before you know (ask the OP) it's impossible to answer. – Bartek Banachewicz Jun 12 '14 at 14:13
@BartekBanachewicz: if the OP were using a smart pointer to clean up, wouldn't have asked this question. – Cheers and hth. - Alf Jun 12 '14 at 15:25
@Cheersandhth.-Alf throwing more assumptions at the problem seems really weird for me, especially if you can just ask. – Bartek Banachewicz Jun 12 '14 at 15:27

4pie0 · Answer 2 · 2014-06-12T14:26:41.493

2

Yes, it will be a leak unless data is kind of handle, smart pointer and not a raw pointer char* data. A safe variant of this is:

class MyObject {

        std::vector<char> data; // or some handle/smart pointer (i.e. unique_ptr)
                                // it might be just std::string
    public:
        MyObject( int sz) : data( sz) {}
};

In this case the memory used is now managed by vector. You can of course do it by yourself what is actually done in vector already and is exception safe. This is you can use approach similar to std::uninitialized_fill.

edited Jun 12 '14 at 14:26

answered Jun 12 '14 at 14:04

4pie0

29,204
9
82
118

@BartekBanachewicz data is a vector in my example – 4pie0 Jun 12 '14 at 14:17
Ah, my bad, I meant OP's `data`. – Bartek Banachewicz Jun 12 '14 at 14:17
true, I've assumed in OP's example data is raw pointer char* data, edited – 4pie0 Jun 12 '14 at 14:20
Might want to mention the best-suited smart-pointer (`std::unique_ptr`), and the semantically far superior `std::string`. Also worth to mention (because the OP uses a constant size), is just adding the array directly to the class, instead of a pointer to it. – Deduplicator Jun 12 '14 at 14:22
It looks like just a coincidence that size is fixed – 4pie0 Jun 12 '14 at 14:25

Bathsheba · Answer 3 · 2014-06-12T14:32:35.220

1

Unless data is a smart pointer (or, more generally, any object that frees the memory passed to it when it destructs) you will leak memory.

The new will need to be balanced with a delete[] (note the []). It's important to note that, since a MyObject instance was not created, the destructor to MyObject will not be called so you cannot rely on any memory cleanup there.

Two alternatives.

free the memory before the throw statement.
Make data a smart pointer (if it isn't already).

2 is preferred - by exploiting RAII it makes code more stable.

edited Jun 12 '14 at 14:32

answered Jun 12 '14 at 14:02

Bathsheba

231,907
34
361
483

You don't know if `data` isn't a smart pointer already, though. – Bartek Banachewicz Jun 12 '14 at 14:09

Cheers and hth. - Alf · Answer 4 · 2014-06-12T15:26:26.097

The situation that you sketch,

MyObject() {
  data = new char[200]; // Will this be leaked?

  if(something_is_wrong)
    throw exception();

}

will¹ leak unless automatic garbage collection is used (and even so it may still leak).

This case is very easily dealt with by using an appropriate standard library container:

MyObject()
{
  string data( 200, '\0' );
  if(something_is_wrong)
    throw exception();
}

And in general preferentially use standard library containers instead of all this new'ing, and if there isn't a suitable container, use smart pointers such as std::unique_ptr.

In short, there's not really a problem, not any more than a call to std::terminate is a problem (just remove the call, or don't do it in the first place).

However, if you define a custom allocation function for the class, and forget to define a corresponding deallocation function, then throwing an exception from a constructor can leak memory.

As a learner simply don't define allocation functions.

As a professional remember to do it properly if at some time you should really need it.

^{¹⁾ Under the reasonable assumption that you're not using a smart pointer to guarantee cleanup and asking this question without mentioning the smart pointer.}

Leaking in constructor

4 Answers4