Am I freeing up the memory used in my program?

Hi All,

I've written a program for an assignment which utilises doubly-linked lists using the STL.

I create a class like so:

Code:

---

class row
{
  private:
 
  list<char> row_chars;
  unsigned int row_number, char_position, row_size;

---

Which has a clear method like so:

Code:

---

void row::clear_row()
{
  row_chars.clear();
}

---

And I create a list of objects of this class:

Code:

---

int main (int argc, char *argv[])
{
  list<row> maze_rows;

---

So in the following code, I'm reading a line into a list of chars which is saved to a row object, then I add that row object to a list of row objects (maze_rows) and subsequently clear the list of chars and begin again.

Code:

---

void load_maze(list<row> &maze_rows, string arg)
{
  string filein;
 
  row row_object(1);     
 
  ifstream fin;
  char ch;
 
  filein = arg;
 
  //open stream to filein
  fin.open(filein.c_str());
  if (!fin)
  {
      cerr << "Unable to load maze " << filein << " \n";
      exit(0);
  }
 
  while (!fin.eof())
  {
      fin.get(ch);
      row_object.store_chars(ch);
      list<row>::iterator itr = maze_rows.begin();
      if(ch == '\n')
      {       
        maze_rows.push_back(row_object);
        row_object.clear_row();
        row_object.new_row();
      }
  }
 
  fin.close();

---

At the end of main I include the following code:

Code:

---

  //Cleanup
  clear_rows(maze_rows);

  return 0;
}

---

Which runs:

Code:

---

void clear_rows(list<row> &maze_rows)
{
  for(list<row>::iterator list_iter = maze_rows.begin();
      list_iter != maze_rows.end(); list_iter++)
  {
      list_iter->clear_row();
  }
}

---

What I want to know is, is this effectively freeing up any memory I had been using for these lists? My grasp on memory management is a bit hazy because I've only ever programmed in Java before and it wasn't that necessary.

Thanks in advance for all your help!

The clear() member function of std::list destroys the elements and sets the size of the container to 0. Although it may happen, especially since this is a doubly linked list, I do not think that you should be so sure that the memory will be released.

Not to worry: when the container object goes out of scope, any remaining elements will be destroyed, and its associated memory will be released. Therefore, you do not need to do any special action to try and ensure that memory will be released.

Thanks for your quick response laserlight.

You're welcome :)

By the way, instead of:

Code:

---

while (!fin.eof())
{
    fin.get(ch);

---

write:

Code:

---

while (fin.get(ch))
{

---

The reason is that the EOF condition is only set after a read has failed to read more input. As a bonus, this simplifies your code.

While rare, it may be useful to clear the memory of a vector before it runs out of scope. You can, portably, like this:

Code:

---

vector<int> someVector;
/* ...*/
vector<int>().swap(someVector);

---

That's the only way I know off to force the vector's memory to be cleared entirely.

Don't use it, though, unless you have fairly good reason to do so. It's likely to only make your program slower significantly, while doing little to improve memory usage.

Edit: Woops, it's a list. But the same holds for lists...

Thanks!

You could make a local scope to make sure the containers go out of scope before the function ends, too. But so long as you are using STL containers (unless you are working with pointers), all memory will be cleaned up correctly when they go out of scope. No need to worry.