How do I free a pointer returned from a function?

Question

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

char* f(void) {
  char *x;
  x = malloc(sizeof(char) * 4);
  strcpy(x, "abc");
  return(x);
}

int main(void) {
  char *a;
  a = f();
  printf("%s", a);
  free(a);
  return(0);
}

Does the variable x in the function have to be freed? If so, how is that possible when I need to return it?

Solution 1

Does the variable x in the function have to be freed?

Yes (kinda, see my later comment). Every call to malloc requires a later call to free. Otherwise, you have a leak. Remember though; you are not "free[ing] x", you are freeing the memory that x refers to.

When you return x a copy of the value (an address) of x is made and returned to the caller. x was declared with automatic storage duration. It is the memory it refers to that must be freed.

If so how is that possible when I need to return it.

Your design has placed the onus on the caller to free the memory. You have already done this in main. Of course, using this method requires that you document the function so that users of your code know that they are receiving an address to memory which was dynamically allocated.

A better approach (IMO) is to take a buffer as an input parameter. Now it is very clear who is responsible for managing this memory (i.e., the caller). Perhaps I don't even want to dynamically allocate it. With this design it is my choice.

void f(char *buf, size_t buf_size) {
  strncpy(buf, "abc", buf_size - 1);
  buf[buf_size-1] = '\0';
}

---

On a side note, you should always be checking the return value of malloc. It can fail, in which case a null pointer will be returned. Also, sizeof(char) is guaranteed to be 1 by the standard, so you can remove that bit and just say malloc(n).

Solution 2

Yes you need to free, but it's already being freed when you do free(a); in main (since a is assigned to equal x in the line a = f();).

Solution 3

Yes it should be freed by the caller. Such as the free in your main.

When you return x in the function f, a copy of the address is passed back to the caller. The caller can call free on that address.

Solution 4

x is destroyed after you exit the function. The value of x is an address that points to a dynamically allocated object. The object still exists after you exit the function.

To free the dynamically object you have to pass the value of x that is returned by the f function to the free function.

View more solutions

Comments

[ouah]

Why do you put parens in the return expression?

[Ed S.]

@ouah: A matter of style. I don't personally, but the project that I work on every day does. It also does things like if(someBoolean == true) which I can't stand, but I know that the original programmer was not ignorant of the boolean type (he's a very bright guy), he just prefers it.

[Lundin]

Whenever you feel the urge to return a pointer to dynamically allocated data, you should ask yourself: "Why am I designing the program so that the allocation and freeing are in different code modules?", "Why isn't the code that understands the nature of the data and the code using the data in the same module?" and similar questions related to proper OO design.

[Sivaram Boina]

how should we achieve this?

[ouah]

@sivaram it is already done in OP's code snippet with the free(a) call.