help understanding free and memory leaks

Hello,

If I understood correctly (and it wouldn't be the first time if I did not), when allocating a local array or struct inside a function one should free it before finishing the function, in order to avoid memory leaks. Am I correct? This may become a huge issue with programs with a GUI, which stay open for a long time and repeatedly call that function.

How about local variables defined within a function? I am guessing it is not a big deal to free them, because they do not get allocated a contiguous block of memory. However, is it considered a "good programming habit" to free local variables? Does it even make sense to think of freeing a local variable?

Thank you very much for you help,

mc61

The easiest thing to remember is this: For each malloc() you should have a free(). That's not bulletproof but it's generally the right thing to do.

When you're asking about freeing local variables, I'm not sure what precisely you mean. If you asked for memory via malloc(), then yes, free it when you're done. Perhaps in the same function, or if you need to use the memory longer, whenever is most convenient. This is correct (assume malloc() succeeds):

Code:

---

void f(void)
{
  char *x;
  x = malloc(some_length);
  snprintf(x, some_length, "foo%s", some_string);
  free(x);
}

---

But you wouldn't do this:

Code:

---

void f(void)
{
  char x[50];
  free(x);
}

---

This is bad because you never allocated x yourself. When the function exits, x will be destroyed automatically. That's what happens with local (or more precisely, automatic) variables.

A memory leak is when you forget to free something; often as a result of "losing" the pointer:

Code:

---

void f(void)
{
  char *x;
  x = malloc(50);
  x = NULL;
  /* oops.. can't free the 50 bytes now */
}

---

I didn't know you could declare structs inside a function ??

Eitherways, I don't think you need to free up arrays, not even sure if you can do that. What you need to do is free up nodes in linked lists and such. But I could be wrong. What do you mean by freeing up structs though? You can't really free them, and even if you could, why would you, it's essential for the running of the program that utilizes the variables defined within it.

You don't need to free local variables in functions, because I think once the function ends, they are lost.

It's possible to declare or define a struct inside a function.
Everything that is allocated by malloc must be freed by free. That simple. This includes arrays and everything else allocated via malloc. Do not call free of anything else. That's undefined behavior.

Thanks guys. As it has happened many times in this board, you clarified a few misconceptions I had.

mc61