Will this specific example produce memory leaks?

Question

class A // blah blah generic abstracty whatever
{
  public:
  A();
  ~A();
};

class B
{
  public:
  B();
  ~B();

  private:
  A* a[8];
};

B::B()
{
  for(int x = 0; x < 8; x++)
  {
    a[x] = new A;
  }
}

B::~B()
{
  for(int x = 0; x < 8; x++)
  {
    delete a[x];
  }
}

I'm just curious if the above code will leak on it's own. Is there any situation where it could leak (aside from if I didn't call delete properly)?

Thanks.

Is it possible for `A`'s constructor to throw an exception in this specific example? — In silico, Mar 12 '13 at 06:16
i think there is not mem leaks, but it will be very simple to understand the leaks if you produce main code. — Dmitry Zagorulkin, Mar 12 '13 at 06:19

Corbin · Accepted Answer · 2013-03-12T06:24:43.530

9

Yes, it's possible if new throws in the constructor.

The destructor would then not be run and any allocations that had already happened will not be released.

To be more specific: if any memory has been dynamically allocated before an exception occurs in the constructor, a memory leak will occur because the destructor of the object will not run.

A simple illustration:

class Leaks
{
private:

    data* d;

public:

    Leaks()
    {
        data = new int;
        throw 1;
    }

    ~Leaks()
    {
        delete data;
    }

};

This is a flawed design. data will always leak here. There's nothing you can do about it. (The only case in which data wouldn't leak would be if the new failed.)

Since new itself can throw, your example code is capable of throwing after one or more allocations, thus leaving you with a leak.

There are three ways to deal with this:

Don't allocate memory (in this situation you would simply use a vector, but obviously sometimes there's no way around using dynamic allocations)
Make sure your constructor can never throw after any memory allocations or if it does throw to clean up the memory before throwing. This is going to make some pretty nasty code though in all but the most trivial of constructors
Use smart pointers

edited Mar 12 '13 at 06:24

answered Mar 12 '13 at 06:14

Corbin

31,183
6
65
77

The destructor will run for those objects - for which `new` was called! – Aniket Inge Mar 12 '13 at 06:16
@Aniket: No it won't. `a` is an array of *pointers* to `A`, not `A` themselves. – In silico Mar 12 '13 at 06:17
@Aniket no `B::~B` will not run at all if `B::B` throws; destructors are only run for completely constructed objects. – Stephen Lin Mar 12 '13 at 06:18
Thanks. You answered my question and more. – Lemmons Mar 12 '13 at 06:41
@Lemmons the answer above touches on this, but just in case it's unclear, you only have to clean up after the `new` allocations that succeeded: if a constructor of an object being allocated with `new` throws, the particular memory allocated for it is automatically deallocated. (if `new` fails due with `std::bad_alloc`, then no memory is allocated at all.) see [(this question)](http://stackoverflow.com/questions/4094996/what-happens-to-the-memory-allocated-by-new-if-the-constructor-throws) for more info... – Stephen Lin Mar 12 '13 at 06:51

score 1 · Answer 2 · answered Mar 12 '13 at 06:14

1

No leaks. This code is fine - no leaks.

answered Mar 12 '13 at 06:14

idoo

300
1
11

score 1 · Answer 3 · answered Mar 12 '13 at 06:15

1

Can't see any leaks or potential leaks there. About the only nasty bit is the hardcoded array size. If you were to change that to be dynamic, you might need to look into the delete[] operator.

answered Mar 12 '13 at 06:15

John3136

27,345
3
44
64

score 1 · Answer 4 · answered Mar 12 '13 at 06:19

1

It seems the code is proper. No leaks.

answered Mar 12 '13 at 06:19

Subhajit

304
1
6

Will this specific example produce memory leaks?

4 Answers4