Question

I am trying to implement a Pool Class that maintains a pool of linked list nodes

Although allocation and deallocation are working correctly, destructor is throwing an exception.

class Pool {
public:

  Pool ();

  ~Pool ();

  tEmployee *GetFromPool (void);

  void GiveToPool (tEmployee * pNode);

  void  PrintPoolSize ();

private:
  int vTop;                        
  tEmployee *vPool;                 
  tEmployee *vDeleted;
};

Here are the implementation of functions

Pool::Pool () 
  :vTop (0), vDeleted (NULL)
{
  vPool = new tEmployee[MAX_POOL];
}

tEmployee* Pool::GetFromPool (void) 
{
  if (vDeleted) {
    tEmployee * temp = vDeleted;
    vDeleted = vDeleted->next;

    return temp;
  }

  if (vTop == MAX_POOL) {

    vPool = new tEmployee[MAX_POOL];
    vTop = 0;
  }

  return vPool + vTop++;
}

void Pool::GiveToPool (tEmployee * pNode)
{
  pNode->next = vDeleted;

  vDeleted = pNode;
}

Pool::~Pool ()
{   
  tEmployee *curr = vDeleted;
  tEmployee *next = 0;

  while (curr) {

    next = curr->next;
    delete curr;    //This line is throwing exception on the second iteration of the loop
    curr = next;
  }

  delete [] vPool;
}

Is it due to heap corruption?

Answer 1

You allocate an array of employees:

vPool = new tEmployee[MAX_POOL];

and then incorrectly attempt to delete them individually:

delete curr; // Don't do this

before correctly deleting the array:

delete [] vPool;

As a general rule, each new must be matched with one delete; you didn’t new the employees individually, so don’t delete them individually.

You’ll also need to maintain a list of pointers to all the arrays you allocate, so you can delete them all in the destructor; currently, you leak all of them except the last one you allocated. I would suggest something like:

std::vector<tEmployee *> vPool; // store all allocated blocks

tEmployee* GetFromPool() {
   if (vDeleted) {
       tEmployee * temp = vDeleted;
       vDeleted = vDeleted->next;
       return temp;
  }

  if (vTop == MAX_POOL) {    
    vPool.push_back(new tEmployee[MAX_POOL]); // add new block to collection
    vTop = 0;
  }

  return vPool.back() + vTop++;
}

~Pool() {
    for (size_t i = 0; i < vPool.size(); ++i)
        delete vPool[i];
}